// $ANTLR 3.1.3 Mar 18, 2009 10:09:25 YaplParser.g 2011-04-26 20:05:24


	using YAPL.Language.Ast;
	using System.Collections.Generic;


using System;
using Antlr.Runtime;
using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;



using Antlr.Runtime.Tree;

namespace  YAPL.Language.SourceParser.Antlr 
{
public class YaplParser : Parser 
{
    public static readonly string[] tokenNames = new string[] 
	{
        "<invalid>", 
		"<EOR>", 
		"<DOWN>", 
		"<UP>", 
		"ASSIGN", 
		"LEFT_PAREN", 
		"RIGHT_PAREN", 
		"LEFT_BRACE", 
		"RIGHT_BRACE", 
		"FUNC", 
		"END", 
		"RET", 
		"CLASS", 
		"WHILE", 
		"IF", 
		"ELSE", 
		"TRUE_C", 
		"FALSE_C", 
		"COMMA", 
		"DOT", 
		"DECREMENT", 
		"INCREMENT", 
		"MINUS", 
		"PLUS", 
		"MULTIPLY", 
		"DIVIDE", 
		"MOD", 
		"AND", 
		"OR", 
		"NOT", 
		"INTEGER", 
		"FLOAT", 
		"BOOL_C", 
		"UPPER", 
		"LETTER", 
		"DIGIT", 
		"CLASS_NAME", 
		"NAME", 
		"DOLLAR", 
		"INSTANCE_NAME", 
		"NONCONTROL_CHAR", 
		"STRING_LITERAL", 
		"SYMBOL", 
		"SPACE", 
		"LOWER", 
		"WHITESPACE", 
		"NEWLINE", 
		"CODE_BLOCK", 
		"STRING_CONSTANT", 
		"INT_CONSTANT", 
		"FLOAT_CONSTANT", 
		"BOOL_CONSTANT", 
		"EXPR_FUNC_CALL", 
		"CLASS_FUNC_CALL", 
		"INSTVAR_FUNC_CALL", 
		"CLASS_REFERENCE", 
		"CLASS_DEF", 
		"FUNC_CALL", 
		"FUNC_DEF", 
		"VAR_FUNC_DEF", 
		"CR_FUNC_DEF", 
		"INSTVAR_FUNC_DEF", 
		"RETURN", 
		"EXPR_LIST", 
		"PARAM_LIST", 
		"PARAM", 
		"VARIABLE", 
		"INSTANCE_VARIABLE", 
		"ASSIGNMENT", 
		"UNARY", 
		"WHILE_ST", 
		"IF_ST"
    };

    public const int DOLLAR = 38;
    public const int CLASS = 12;
    public const int WHILE = 13;
    public const int LETTER = 34;
    public const int MOD = 26;
    public const int INSTANCE_NAME = 39;
    public const int PARAM = 65;
    public const int FLOAT = 31;
    public const int NOT = 29;
    public const int AND = 27;
    public const int SPACE = 43;
    public const int EOF = -1;
    public const int CLASS_REFERENCE = 55;
    public const int FUNC_CALL = 57;
    public const int IF = 14;
    public const int FALSE_C = 17;
    public const int EXPR_LIST = 63;
    public const int RIGHT_PAREN = 6;
    public const int RET = 11;
    public const int NAME = 37;
    public const int STRING_LITERAL = 41;
    public const int BOOL_CONSTANT = 51;
    public const int MULTIPLY = 24;
    public const int COMMA = 18;
    public const int RETURN = 62;
    public const int PLUS = 23;
    public const int DIGIT = 35;
    public const int UNARY = 69;
    public const int DOT = 19;
    public const int DIVIDE = 25;
    public const int RIGHT_BRACE = 8;
    public const int INTEGER = 30;
    public const int INT_CONSTANT = 49;
    public const int BOOL_C = 32;
    public const int INSTVAR_FUNC_CALL = 54;
    public const int WHILE_ST = 70;
    public const int FLOAT_CONSTANT = 50;
    public const int CLASS_NAME = 36;
    public const int SYMBOL = 42;
    public const int ELSE = 15;
    public const int WHITESPACE = 45;
    public const int FUNC_DEF = 58;
    public const int MINUS = 22;
    public const int STRING_CONSTANT = 48;
    public const int DECREMENT = 20;
    public const int IF_ST = 71;
    public const int EXPR_FUNC_CALL = 52;
    public const int INCREMENT = 21;
    public const int PARAM_LIST = 64;
    public const int VARIABLE = 66;
    public const int NEWLINE = 46;
    public const int NONCONTROL_CHAR = 40;
    public const int FUNC = 9;
    public const int LEFT_BRACE = 7;
    public const int INSTANCE_VARIABLE = 67;
    public const int CR_FUNC_DEF = 60;
    public const int OR = 28;
    public const int ASSIGN = 4;
    public const int VAR_FUNC_DEF = 59;
    public const int CODE_BLOCK = 47;
    public const int LEFT_PAREN = 5;
    public const int ASSIGNMENT = 68;
    public const int TRUE_C = 16;
    public const int LOWER = 44;
    public const int END = 10;
    public const int INSTVAR_FUNC_DEF = 61;
    public const int CLASS_DEF = 56;
    public const int UPPER = 33;
    public const int CLASS_FUNC_CALL = 53;

    // delegates
    // delegators



        public YaplParser(ITokenStream input)
    		: this(input, new RecognizerSharedState()) {
        }

        public YaplParser(ITokenStream input, RecognizerSharedState state)
    		: base(input, state) {
            InitializeCyclicDFAs();

             
       }
        
    protected ITreeAdaptor adaptor = new CommonTreeAdaptor();

    public ITreeAdaptor TreeAdaptor
    {
        get { return this.adaptor; }
        set {
    	this.adaptor = value;
    	}
    }

    override public string[] TokenNames {
		get { return YaplParser.tokenNames; }
    }

    override public string GrammarFileName {
		get { return "YaplParser.g"; }
    }


    public class prog_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "prog"
    // YaplParser.g:46:1: prog : code_block EOF ;
    public YaplParser.prog_return prog() // throws RecognitionException [1]
    {   
        YaplParser.prog_return retval = new YaplParser.prog_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken EOF2 = null;
        YaplParser.code_block_return code_block1 = null;


        CommonTree EOF2_tree=null;

        try 
    	{
            // YaplParser.g:46:5: ( code_block EOF )
            // YaplParser.g:46:7: code_block EOF
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_code_block_in_prog166);
            	code_block1 = code_block();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, code_block1.Tree);
            	EOF2=(IToken)Match(input,EOF,FOLLOW_EOF_in_prog168); 

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "prog"

    public class function_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "function"
    // YaplParser.g:49:1: function : ( FUNC fname= NAME LEFT_PAREN param_list RIGHT_PAREN newlines code_block END -> ^( FUNC_DEF $fname param_list code_block ) | FUNC variable DOT fname= NAME LEFT_PAREN param_list RIGHT_PAREN newlines code_block END -> ^( VAR_FUNC_DEF $fname param_list code_block variable ) | FUNC class_reference DOT fname= NAME LEFT_PAREN param_list RIGHT_PAREN newlines code_block END -> ^( CR_FUNC_DEF $fname param_list code_block class_reference ) | FUNC instance_variable DOT fname= NAME LEFT_PAREN param_list RIGHT_PAREN newlines code_block END -> ^( INSTVAR_FUNC_DEF $fname param_list code_block instance_variable ) );
    public YaplParser.function_return function() // throws RecognitionException [1]
    {   
        YaplParser.function_return retval = new YaplParser.function_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken fname = null;
        IToken FUNC3 = null;
        IToken LEFT_PAREN4 = null;
        IToken RIGHT_PAREN6 = null;
        IToken END9 = null;
        IToken FUNC10 = null;
        IToken DOT12 = null;
        IToken LEFT_PAREN13 = null;
        IToken RIGHT_PAREN15 = null;
        IToken END18 = null;
        IToken FUNC19 = null;
        IToken DOT21 = null;
        IToken LEFT_PAREN22 = null;
        IToken RIGHT_PAREN24 = null;
        IToken END27 = null;
        IToken FUNC28 = null;
        IToken DOT30 = null;
        IToken LEFT_PAREN31 = null;
        IToken RIGHT_PAREN33 = null;
        IToken END36 = null;
        YaplParser.param_list_return param_list5 = null;

        YaplParser.newlines_return newlines7 = null;

        YaplParser.code_block_return code_block8 = null;

        YaplParser.variable_return variable11 = null;

        YaplParser.param_list_return param_list14 = null;

        YaplParser.newlines_return newlines16 = null;

        YaplParser.code_block_return code_block17 = null;

        YaplParser.class_reference_return class_reference20 = null;

        YaplParser.param_list_return param_list23 = null;

        YaplParser.newlines_return newlines25 = null;

        YaplParser.code_block_return code_block26 = null;

        YaplParser.instance_variable_return instance_variable29 = null;

        YaplParser.param_list_return param_list32 = null;

        YaplParser.newlines_return newlines34 = null;

        YaplParser.code_block_return code_block35 = null;


        CommonTree fname_tree=null;
        CommonTree FUNC3_tree=null;
        CommonTree LEFT_PAREN4_tree=null;
        CommonTree RIGHT_PAREN6_tree=null;
        CommonTree END9_tree=null;
        CommonTree FUNC10_tree=null;
        CommonTree DOT12_tree=null;
        CommonTree LEFT_PAREN13_tree=null;
        CommonTree RIGHT_PAREN15_tree=null;
        CommonTree END18_tree=null;
        CommonTree FUNC19_tree=null;
        CommonTree DOT21_tree=null;
        CommonTree LEFT_PAREN22_tree=null;
        CommonTree RIGHT_PAREN24_tree=null;
        CommonTree END27_tree=null;
        CommonTree FUNC28_tree=null;
        CommonTree DOT30_tree=null;
        CommonTree LEFT_PAREN31_tree=null;
        CommonTree RIGHT_PAREN33_tree=null;
        CommonTree END36_tree=null;
        RewriteRuleTokenStream stream_LEFT_PAREN = new RewriteRuleTokenStream(adaptor,"token LEFT_PAREN");
        RewriteRuleTokenStream stream_RIGHT_PAREN = new RewriteRuleTokenStream(adaptor,"token RIGHT_PAREN");
        RewriteRuleTokenStream stream_NAME = new RewriteRuleTokenStream(adaptor,"token NAME");
        RewriteRuleTokenStream stream_DOT = new RewriteRuleTokenStream(adaptor,"token DOT");
        RewriteRuleTokenStream stream_END = new RewriteRuleTokenStream(adaptor,"token END");
        RewriteRuleTokenStream stream_FUNC = new RewriteRuleTokenStream(adaptor,"token FUNC");
        RewriteRuleSubtreeStream stream_class_reference = new RewriteRuleSubtreeStream(adaptor,"rule class_reference");
        RewriteRuleSubtreeStream stream_newlines = new RewriteRuleSubtreeStream(adaptor,"rule newlines");
        RewriteRuleSubtreeStream stream_instance_variable = new RewriteRuleSubtreeStream(adaptor,"rule instance_variable");
        RewriteRuleSubtreeStream stream_code_block = new RewriteRuleSubtreeStream(adaptor,"rule code_block");
        RewriteRuleSubtreeStream stream_variable = new RewriteRuleSubtreeStream(adaptor,"rule variable");
        RewriteRuleSubtreeStream stream_param_list = new RewriteRuleSubtreeStream(adaptor,"rule param_list");
        try 
    	{
            // YaplParser.g:49:9: ( FUNC fname= NAME LEFT_PAREN param_list RIGHT_PAREN newlines code_block END -> ^( FUNC_DEF $fname param_list code_block ) | FUNC variable DOT fname= NAME LEFT_PAREN param_list RIGHT_PAREN newlines code_block END -> ^( VAR_FUNC_DEF $fname param_list code_block variable ) | FUNC class_reference DOT fname= NAME LEFT_PAREN param_list RIGHT_PAREN newlines code_block END -> ^( CR_FUNC_DEF $fname param_list code_block class_reference ) | FUNC instance_variable DOT fname= NAME LEFT_PAREN param_list RIGHT_PAREN newlines code_block END -> ^( INSTVAR_FUNC_DEF $fname param_list code_block instance_variable ) )
            int alt1 = 4;
            int LA1_0 = input.LA(1);

            if ( (LA1_0 == FUNC) )
            {
                switch ( input.LA(2) ) 
                {
                case NAME:
                	{
                    int LA1_2 = input.LA(3);

                    if ( (LA1_2 == LEFT_PAREN) )
                    {
                        alt1 = 1;
                    }
                    else if ( (LA1_2 == DOT) )
                    {
                        alt1 = 2;
                    }
                    else 
                    {
                        NoViableAltException nvae_d1s2 =
                            new NoViableAltException("", 1, 2, input);

                        throw nvae_d1s2;
                    }
                    }
                    break;
                case INSTANCE_NAME:
                	{
                    alt1 = 4;
                    }
                    break;
                case CLASS_NAME:
                	{
                    alt1 = 3;
                    }
                    break;
                	default:
                	    NoViableAltException nvae_d1s1 =
                	        new NoViableAltException("", 1, 1, input);

                	    throw nvae_d1s1;
                }

            }
            else 
            {
                NoViableAltException nvae_d1s0 =
                    new NoViableAltException("", 1, 0, input);

                throw nvae_d1s0;
            }
            switch (alt1) 
            {
                case 1 :
                    // YaplParser.g:50:5: FUNC fname= NAME LEFT_PAREN param_list RIGHT_PAREN newlines code_block END
                    {
                    	FUNC3=(IToken)Match(input,FUNC,FOLLOW_FUNC_in_function181);  
                    	stream_FUNC.Add(FUNC3);

                    	fname=(IToken)Match(input,NAME,FOLLOW_NAME_in_function185);  
                    	stream_NAME.Add(fname);

                    	LEFT_PAREN4=(IToken)Match(input,LEFT_PAREN,FOLLOW_LEFT_PAREN_in_function187);  
                    	stream_LEFT_PAREN.Add(LEFT_PAREN4);

                    	PushFollow(FOLLOW_param_list_in_function189);
                    	param_list5 = param_list();
                    	state.followingStackPointer--;

                    	stream_param_list.Add(param_list5.Tree);
                    	RIGHT_PAREN6=(IToken)Match(input,RIGHT_PAREN,FOLLOW_RIGHT_PAREN_in_function191);  
                    	stream_RIGHT_PAREN.Add(RIGHT_PAREN6);

                    	PushFollow(FOLLOW_newlines_in_function193);
                    	newlines7 = newlines();
                    	state.followingStackPointer--;

                    	stream_newlines.Add(newlines7.Tree);
                    	PushFollow(FOLLOW_code_block_in_function195);
                    	code_block8 = code_block();
                    	state.followingStackPointer--;

                    	stream_code_block.Add(code_block8.Tree);
                    	END9=(IToken)Match(input,END,FOLLOW_END_in_function197);  
                    	stream_END.Add(END9);



                    	// AST REWRITE
                    	// elements:          fname, code_block, param_list
                    	// token labels:      fname
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleTokenStream stream_fname = new RewriteRuleTokenStream(adaptor, "token fname", fname);
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 50:79: -> ^( FUNC_DEF $fname param_list code_block )
                    	{
                    	    // YaplParser.g:50:82: ^( FUNC_DEF $fname param_list code_block )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(FUNC_DEF, "FUNC_DEF"), root_1);

                    	    adaptor.AddChild(root_1, stream_fname.NextNode());
                    	    adaptor.AddChild(root_1, stream_param_list.NextTree());
                    	    adaptor.AddChild(root_1, stream_code_block.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;
                case 2 :
                    // YaplParser.g:51:5: FUNC variable DOT fname= NAME LEFT_PAREN param_list RIGHT_PAREN newlines code_block END
                    {
                    	FUNC10=(IToken)Match(input,FUNC,FOLLOW_FUNC_in_function216);  
                    	stream_FUNC.Add(FUNC10);

                    	PushFollow(FOLLOW_variable_in_function218);
                    	variable11 = variable();
                    	state.followingStackPointer--;

                    	stream_variable.Add(variable11.Tree);
                    	DOT12=(IToken)Match(input,DOT,FOLLOW_DOT_in_function220);  
                    	stream_DOT.Add(DOT12);

                    	fname=(IToken)Match(input,NAME,FOLLOW_NAME_in_function224);  
                    	stream_NAME.Add(fname);

                    	LEFT_PAREN13=(IToken)Match(input,LEFT_PAREN,FOLLOW_LEFT_PAREN_in_function226);  
                    	stream_LEFT_PAREN.Add(LEFT_PAREN13);

                    	PushFollow(FOLLOW_param_list_in_function228);
                    	param_list14 = param_list();
                    	state.followingStackPointer--;

                    	stream_param_list.Add(param_list14.Tree);
                    	RIGHT_PAREN15=(IToken)Match(input,RIGHT_PAREN,FOLLOW_RIGHT_PAREN_in_function230);  
                    	stream_RIGHT_PAREN.Add(RIGHT_PAREN15);

                    	PushFollow(FOLLOW_newlines_in_function232);
                    	newlines16 = newlines();
                    	state.followingStackPointer--;

                    	stream_newlines.Add(newlines16.Tree);
                    	PushFollow(FOLLOW_code_block_in_function234);
                    	code_block17 = code_block();
                    	state.followingStackPointer--;

                    	stream_code_block.Add(code_block17.Tree);
                    	END18=(IToken)Match(input,END,FOLLOW_END_in_function236);  
                    	stream_END.Add(END18);



                    	// AST REWRITE
                    	// elements:          variable, param_list, fname, code_block
                    	// token labels:      fname
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleTokenStream stream_fname = new RewriteRuleTokenStream(adaptor, "token fname", fname);
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 51:92: -> ^( VAR_FUNC_DEF $fname param_list code_block variable )
                    	{
                    	    // YaplParser.g:51:95: ^( VAR_FUNC_DEF $fname param_list code_block variable )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(VAR_FUNC_DEF, "VAR_FUNC_DEF"), root_1);

                    	    adaptor.AddChild(root_1, stream_fname.NextNode());
                    	    adaptor.AddChild(root_1, stream_param_list.NextTree());
                    	    adaptor.AddChild(root_1, stream_code_block.NextTree());
                    	    adaptor.AddChild(root_1, stream_variable.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;
                case 3 :
                    // YaplParser.g:52:5: FUNC class_reference DOT fname= NAME LEFT_PAREN param_list RIGHT_PAREN newlines code_block END
                    {
                    	FUNC19=(IToken)Match(input,FUNC,FOLLOW_FUNC_in_function257);  
                    	stream_FUNC.Add(FUNC19);

                    	PushFollow(FOLLOW_class_reference_in_function259);
                    	class_reference20 = class_reference();
                    	state.followingStackPointer--;

                    	stream_class_reference.Add(class_reference20.Tree);
                    	DOT21=(IToken)Match(input,DOT,FOLLOW_DOT_in_function261);  
                    	stream_DOT.Add(DOT21);

                    	fname=(IToken)Match(input,NAME,FOLLOW_NAME_in_function265);  
                    	stream_NAME.Add(fname);

                    	LEFT_PAREN22=(IToken)Match(input,LEFT_PAREN,FOLLOW_LEFT_PAREN_in_function267);  
                    	stream_LEFT_PAREN.Add(LEFT_PAREN22);

                    	PushFollow(FOLLOW_param_list_in_function269);
                    	param_list23 = param_list();
                    	state.followingStackPointer--;

                    	stream_param_list.Add(param_list23.Tree);
                    	RIGHT_PAREN24=(IToken)Match(input,RIGHT_PAREN,FOLLOW_RIGHT_PAREN_in_function271);  
                    	stream_RIGHT_PAREN.Add(RIGHT_PAREN24);

                    	PushFollow(FOLLOW_newlines_in_function273);
                    	newlines25 = newlines();
                    	state.followingStackPointer--;

                    	stream_newlines.Add(newlines25.Tree);
                    	PushFollow(FOLLOW_code_block_in_function275);
                    	code_block26 = code_block();
                    	state.followingStackPointer--;

                    	stream_code_block.Add(code_block26.Tree);
                    	END27=(IToken)Match(input,END,FOLLOW_END_in_function277);  
                    	stream_END.Add(END27);



                    	// AST REWRITE
                    	// elements:          param_list, code_block, fname, class_reference
                    	// token labels:      fname
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleTokenStream stream_fname = new RewriteRuleTokenStream(adaptor, "token fname", fname);
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 52:99: -> ^( CR_FUNC_DEF $fname param_list code_block class_reference )
                    	{
                    	    // YaplParser.g:52:102: ^( CR_FUNC_DEF $fname param_list code_block class_reference )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CR_FUNC_DEF, "CR_FUNC_DEF"), root_1);

                    	    adaptor.AddChild(root_1, stream_fname.NextNode());
                    	    adaptor.AddChild(root_1, stream_param_list.NextTree());
                    	    adaptor.AddChild(root_1, stream_code_block.NextTree());
                    	    adaptor.AddChild(root_1, stream_class_reference.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;
                case 4 :
                    // YaplParser.g:53:5: FUNC instance_variable DOT fname= NAME LEFT_PAREN param_list RIGHT_PAREN newlines code_block END
                    {
                    	FUNC28=(IToken)Match(input,FUNC,FOLLOW_FUNC_in_function298);  
                    	stream_FUNC.Add(FUNC28);

                    	PushFollow(FOLLOW_instance_variable_in_function300);
                    	instance_variable29 = instance_variable();
                    	state.followingStackPointer--;

                    	stream_instance_variable.Add(instance_variable29.Tree);
                    	DOT30=(IToken)Match(input,DOT,FOLLOW_DOT_in_function302);  
                    	stream_DOT.Add(DOT30);

                    	fname=(IToken)Match(input,NAME,FOLLOW_NAME_in_function306);  
                    	stream_NAME.Add(fname);

                    	LEFT_PAREN31=(IToken)Match(input,LEFT_PAREN,FOLLOW_LEFT_PAREN_in_function308);  
                    	stream_LEFT_PAREN.Add(LEFT_PAREN31);

                    	PushFollow(FOLLOW_param_list_in_function310);
                    	param_list32 = param_list();
                    	state.followingStackPointer--;

                    	stream_param_list.Add(param_list32.Tree);
                    	RIGHT_PAREN33=(IToken)Match(input,RIGHT_PAREN,FOLLOW_RIGHT_PAREN_in_function312);  
                    	stream_RIGHT_PAREN.Add(RIGHT_PAREN33);

                    	PushFollow(FOLLOW_newlines_in_function314);
                    	newlines34 = newlines();
                    	state.followingStackPointer--;

                    	stream_newlines.Add(newlines34.Tree);
                    	PushFollow(FOLLOW_code_block_in_function316);
                    	code_block35 = code_block();
                    	state.followingStackPointer--;

                    	stream_code_block.Add(code_block35.Tree);
                    	END36=(IToken)Match(input,END,FOLLOW_END_in_function318);  
                    	stream_END.Add(END36);



                    	// AST REWRITE
                    	// elements:          code_block, param_list, fname, instance_variable
                    	// token labels:      fname
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleTokenStream stream_fname = new RewriteRuleTokenStream(adaptor, "token fname", fname);
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 53:101: -> ^( INSTVAR_FUNC_DEF $fname param_list code_block instance_variable )
                    	{
                    	    // YaplParser.g:53:104: ^( INSTVAR_FUNC_DEF $fname param_list code_block instance_variable )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(INSTVAR_FUNC_DEF, "INSTVAR_FUNC_DEF"), root_1);

                    	    adaptor.AddChild(root_1, stream_fname.NextNode());
                    	    adaptor.AddChild(root_1, stream_param_list.NextTree());
                    	    adaptor.AddChild(root_1, stream_code_block.NextTree());
                    	    adaptor.AddChild(root_1, stream_instance_variable.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "function"

    public class while_loop_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "while_loop"
    // YaplParser.g:56:1: while_loop : WHILE LEFT_PAREN expression RIGHT_PAREN newlines code_block END -> ^( WHILE_ST expression code_block ) ;
    public YaplParser.while_loop_return while_loop() // throws RecognitionException [1]
    {   
        YaplParser.while_loop_return retval = new YaplParser.while_loop_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken WHILE37 = null;
        IToken LEFT_PAREN38 = null;
        IToken RIGHT_PAREN40 = null;
        IToken END43 = null;
        YaplParser.expression_return expression39 = null;

        YaplParser.newlines_return newlines41 = null;

        YaplParser.code_block_return code_block42 = null;


        CommonTree WHILE37_tree=null;
        CommonTree LEFT_PAREN38_tree=null;
        CommonTree RIGHT_PAREN40_tree=null;
        CommonTree END43_tree=null;
        RewriteRuleTokenStream stream_LEFT_PAREN = new RewriteRuleTokenStream(adaptor,"token LEFT_PAREN");
        RewriteRuleTokenStream stream_RIGHT_PAREN = new RewriteRuleTokenStream(adaptor,"token RIGHT_PAREN");
        RewriteRuleTokenStream stream_WHILE = new RewriteRuleTokenStream(adaptor,"token WHILE");
        RewriteRuleTokenStream stream_END = new RewriteRuleTokenStream(adaptor,"token END");
        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor,"rule expression");
        RewriteRuleSubtreeStream stream_newlines = new RewriteRuleSubtreeStream(adaptor,"rule newlines");
        RewriteRuleSubtreeStream stream_code_block = new RewriteRuleSubtreeStream(adaptor,"rule code_block");
        try 
    	{
            // YaplParser.g:56:11: ( WHILE LEFT_PAREN expression RIGHT_PAREN newlines code_block END -> ^( WHILE_ST expression code_block ) )
            // YaplParser.g:56:13: WHILE LEFT_PAREN expression RIGHT_PAREN newlines code_block END
            {
            	WHILE37=(IToken)Match(input,WHILE,FOLLOW_WHILE_in_while_loop343);  
            	stream_WHILE.Add(WHILE37);

            	LEFT_PAREN38=(IToken)Match(input,LEFT_PAREN,FOLLOW_LEFT_PAREN_in_while_loop345);  
            	stream_LEFT_PAREN.Add(LEFT_PAREN38);

            	PushFollow(FOLLOW_expression_in_while_loop347);
            	expression39 = expression();
            	state.followingStackPointer--;

            	stream_expression.Add(expression39.Tree);
            	RIGHT_PAREN40=(IToken)Match(input,RIGHT_PAREN,FOLLOW_RIGHT_PAREN_in_while_loop349);  
            	stream_RIGHT_PAREN.Add(RIGHT_PAREN40);

            	PushFollow(FOLLOW_newlines_in_while_loop351);
            	newlines41 = newlines();
            	state.followingStackPointer--;

            	stream_newlines.Add(newlines41.Tree);
            	PushFollow(FOLLOW_code_block_in_while_loop353);
            	code_block42 = code_block();
            	state.followingStackPointer--;

            	stream_code_block.Add(code_block42.Tree);
            	END43=(IToken)Match(input,END,FOLLOW_END_in_while_loop355);  
            	stream_END.Add(END43);



            	// AST REWRITE
            	// elements:          expression, code_block
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 56:77: -> ^( WHILE_ST expression code_block )
            	{
            	    // YaplParser.g:56:80: ^( WHILE_ST expression code_block )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(WHILE_ST, "WHILE_ST"), root_1);

            	    adaptor.AddChild(root_1, stream_expression.NextTree());
            	    adaptor.AddChild(root_1, stream_code_block.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "while_loop"

    public class if_statement_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "if_statement"
    // YaplParser.g:59:1: if_statement : IF LEFT_PAREN expression RIGHT_PAREN newlines th= code_block ( ELSE newlines el= code_block )? END -> ^( IF_ST expression $th ( $el)? ) ;
    public YaplParser.if_statement_return if_statement() // throws RecognitionException [1]
    {   
        YaplParser.if_statement_return retval = new YaplParser.if_statement_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken IF44 = null;
        IToken LEFT_PAREN45 = null;
        IToken RIGHT_PAREN47 = null;
        IToken ELSE49 = null;
        IToken END51 = null;
        YaplParser.code_block_return th = null;

        YaplParser.code_block_return el = null;

        YaplParser.expression_return expression46 = null;

        YaplParser.newlines_return newlines48 = null;

        YaplParser.newlines_return newlines50 = null;


        CommonTree IF44_tree=null;
        CommonTree LEFT_PAREN45_tree=null;
        CommonTree RIGHT_PAREN47_tree=null;
        CommonTree ELSE49_tree=null;
        CommonTree END51_tree=null;
        RewriteRuleTokenStream stream_LEFT_PAREN = new RewriteRuleTokenStream(adaptor,"token LEFT_PAREN");
        RewriteRuleTokenStream stream_RIGHT_PAREN = new RewriteRuleTokenStream(adaptor,"token RIGHT_PAREN");
        RewriteRuleTokenStream stream_END = new RewriteRuleTokenStream(adaptor,"token END");
        RewriteRuleTokenStream stream_IF = new RewriteRuleTokenStream(adaptor,"token IF");
        RewriteRuleTokenStream stream_ELSE = new RewriteRuleTokenStream(adaptor,"token ELSE");
        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor,"rule expression");
        RewriteRuleSubtreeStream stream_newlines = new RewriteRuleSubtreeStream(adaptor,"rule newlines");
        RewriteRuleSubtreeStream stream_code_block = new RewriteRuleSubtreeStream(adaptor,"rule code_block");
        try 
    	{
            // YaplParser.g:59:13: ( IF LEFT_PAREN expression RIGHT_PAREN newlines th= code_block ( ELSE newlines el= code_block )? END -> ^( IF_ST expression $th ( $el)? ) )
            // YaplParser.g:60:5: IF LEFT_PAREN expression RIGHT_PAREN newlines th= code_block ( ELSE newlines el= code_block )? END
            {
            	IF44=(IToken)Match(input,IF,FOLLOW_IF_in_if_statement377);  
            	stream_IF.Add(IF44);

            	LEFT_PAREN45=(IToken)Match(input,LEFT_PAREN,FOLLOW_LEFT_PAREN_in_if_statement379);  
            	stream_LEFT_PAREN.Add(LEFT_PAREN45);

            	PushFollow(FOLLOW_expression_in_if_statement381);
            	expression46 = expression();
            	state.followingStackPointer--;

            	stream_expression.Add(expression46.Tree);
            	RIGHT_PAREN47=(IToken)Match(input,RIGHT_PAREN,FOLLOW_RIGHT_PAREN_in_if_statement383);  
            	stream_RIGHT_PAREN.Add(RIGHT_PAREN47);

            	PushFollow(FOLLOW_newlines_in_if_statement385);
            	newlines48 = newlines();
            	state.followingStackPointer--;

            	stream_newlines.Add(newlines48.Tree);
            	PushFollow(FOLLOW_code_block_in_if_statement389);
            	th = code_block();
            	state.followingStackPointer--;

            	stream_code_block.Add(th.Tree);
            	// YaplParser.g:60:65: ( ELSE newlines el= code_block )?
            	int alt2 = 2;
            	int LA2_0 = input.LA(1);

            	if ( (LA2_0 == ELSE) )
            	{
            	    alt2 = 1;
            	}
            	switch (alt2) 
            	{
            	    case 1 :
            	        // YaplParser.g:60:66: ELSE newlines el= code_block
            	        {
            	        	ELSE49=(IToken)Match(input,ELSE,FOLLOW_ELSE_in_if_statement392);  
            	        	stream_ELSE.Add(ELSE49);

            	        	PushFollow(FOLLOW_newlines_in_if_statement394);
            	        	newlines50 = newlines();
            	        	state.followingStackPointer--;

            	        	stream_newlines.Add(newlines50.Tree);
            	        	PushFollow(FOLLOW_code_block_in_if_statement398);
            	        	el = code_block();
            	        	state.followingStackPointer--;

            	        	stream_code_block.Add(el.Tree);

            	        }
            	        break;

            	}

            	END51=(IToken)Match(input,END,FOLLOW_END_in_if_statement402);  
            	stream_END.Add(END51);



            	// AST REWRITE
            	// elements:          el, th, expression
            	// token labels:      
            	// rule labels:       retval, el, th
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
            	RewriteRuleSubtreeStream stream_el = new RewriteRuleSubtreeStream(adaptor, "rule el", el!=null ? el.Tree : null);
            	RewriteRuleSubtreeStream stream_th = new RewriteRuleSubtreeStream(adaptor, "rule th", th!=null ? th.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 60:100: -> ^( IF_ST expression $th ( $el)? )
            	{
            	    // YaplParser.g:60:103: ^( IF_ST expression $th ( $el)? )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(IF_ST, "IF_ST"), root_1);

            	    adaptor.AddChild(root_1, stream_expression.NextTree());
            	    adaptor.AddChild(root_1, stream_th.NextTree());
            	    // YaplParser.g:60:126: ( $el)?
            	    if ( stream_el.HasNext() )
            	    {
            	        adaptor.AddChild(root_1, stream_el.NextTree());

            	    }
            	    stream_el.Reset();

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "if_statement"

    public class class_def_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "class_def"
    // YaplParser.g:63:1: class_def : CLASS cname= CLASS_NAME newlines code_block END -> ^( CLASS_DEF $cname code_block ) ;
    public YaplParser.class_def_return class_def() // throws RecognitionException [1]
    {   
        YaplParser.class_def_return retval = new YaplParser.class_def_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken cname = null;
        IToken CLASS52 = null;
        IToken END55 = null;
        YaplParser.newlines_return newlines53 = null;

        YaplParser.code_block_return code_block54 = null;


        CommonTree cname_tree=null;
        CommonTree CLASS52_tree=null;
        CommonTree END55_tree=null;
        RewriteRuleTokenStream stream_CLASS = new RewriteRuleTokenStream(adaptor,"token CLASS");
        RewriteRuleTokenStream stream_CLASS_NAME = new RewriteRuleTokenStream(adaptor,"token CLASS_NAME");
        RewriteRuleTokenStream stream_END = new RewriteRuleTokenStream(adaptor,"token END");
        RewriteRuleSubtreeStream stream_newlines = new RewriteRuleSubtreeStream(adaptor,"rule newlines");
        RewriteRuleSubtreeStream stream_code_block = new RewriteRuleSubtreeStream(adaptor,"rule code_block");
        try 
    	{
            // YaplParser.g:63:10: ( CLASS cname= CLASS_NAME newlines code_block END -> ^( CLASS_DEF $cname code_block ) )
            // YaplParser.g:63:12: CLASS cname= CLASS_NAME newlines code_block END
            {
            	CLASS52=(IToken)Match(input,CLASS,FOLLOW_CLASS_in_class_def427);  
            	stream_CLASS.Add(CLASS52);

            	cname=(IToken)Match(input,CLASS_NAME,FOLLOW_CLASS_NAME_in_class_def431);  
            	stream_CLASS_NAME.Add(cname);

            	PushFollow(FOLLOW_newlines_in_class_def433);
            	newlines53 = newlines();
            	state.followingStackPointer--;

            	stream_newlines.Add(newlines53.Tree);
            	PushFollow(FOLLOW_code_block_in_class_def435);
            	code_block54 = code_block();
            	state.followingStackPointer--;

            	stream_code_block.Add(code_block54.Tree);
            	END55=(IToken)Match(input,END,FOLLOW_END_in_class_def437);  
            	stream_END.Add(END55);



            	// AST REWRITE
            	// elements:          code_block, cname
            	// token labels:      cname
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleTokenStream stream_cname = new RewriteRuleTokenStream(adaptor, "token cname", cname);
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 63:59: -> ^( CLASS_DEF $cname code_block )
            	{
            	    // YaplParser.g:63:62: ^( CLASS_DEF $cname code_block )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CLASS_DEF, "CLASS_DEF"), root_1);

            	    adaptor.AddChild(root_1, stream_cname.NextNode());
            	    adaptor.AddChild(root_1, stream_code_block.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "class_def"

    public class param_list_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "param_list"
    // YaplParser.g:65:1: param_list : ( param ( COMMA param )* )? -> ^( PARAM_LIST ( param )* ) ;
    public YaplParser.param_list_return param_list() // throws RecognitionException [1]
    {   
        YaplParser.param_list_return retval = new YaplParser.param_list_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken COMMA57 = null;
        YaplParser.param_return param56 = null;

        YaplParser.param_return param58 = null;


        CommonTree COMMA57_tree=null;
        RewriteRuleTokenStream stream_COMMA = new RewriteRuleTokenStream(adaptor,"token COMMA");
        RewriteRuleSubtreeStream stream_param = new RewriteRuleSubtreeStream(adaptor,"rule param");
        try 
    	{
            // YaplParser.g:65:11: ( ( param ( COMMA param )* )? -> ^( PARAM_LIST ( param )* ) )
            // YaplParser.g:65:13: ( param ( COMMA param )* )?
            {
            	// YaplParser.g:65:13: ( param ( COMMA param )* )?
            	int alt4 = 2;
            	int LA4_0 = input.LA(1);

            	if ( (LA4_0 == NAME) )
            	{
            	    alt4 = 1;
            	}
            	switch (alt4) 
            	{
            	    case 1 :
            	        // YaplParser.g:65:14: param ( COMMA param )*
            	        {
            	        	PushFollow(FOLLOW_param_in_param_list456);
            	        	param56 = param();
            	        	state.followingStackPointer--;

            	        	stream_param.Add(param56.Tree);
            	        	// YaplParser.g:65:20: ( COMMA param )*
            	        	do 
            	        	{
            	        	    int alt3 = 2;
            	        	    int LA3_0 = input.LA(1);

            	        	    if ( (LA3_0 == COMMA) )
            	        	    {
            	        	        alt3 = 1;
            	        	    }


            	        	    switch (alt3) 
            	        		{
            	        			case 1 :
            	        			    // YaplParser.g:65:21: COMMA param
            	        			    {
            	        			    	COMMA57=(IToken)Match(input,COMMA,FOLLOW_COMMA_in_param_list459);  
            	        			    	stream_COMMA.Add(COMMA57);

            	        			    	PushFollow(FOLLOW_param_in_param_list461);
            	        			    	param58 = param();
            	        			    	state.followingStackPointer--;

            	        			    	stream_param.Add(param58.Tree);

            	        			    }
            	        			    break;

            	        			default:
            	        			    goto loop3;
            	        	    }
            	        	} while (true);

            	        	loop3:
            	        		;	// Stops C# compiler whining that label 'loop3' has no statements


            	        }
            	        break;

            	}



            	// AST REWRITE
            	// elements:          param
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 65:37: -> ^( PARAM_LIST ( param )* )
            	{
            	    // YaplParser.g:65:40: ^( PARAM_LIST ( param )* )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(PARAM_LIST, "PARAM_LIST"), root_1);

            	    // YaplParser.g:65:53: ( param )*
            	    while ( stream_param.HasNext() )
            	    {
            	        adaptor.AddChild(root_1, stream_param.NextTree());

            	    }
            	    stream_param.Reset();

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "param_list"

    public class param_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "param"
    // YaplParser.g:67:1: param : NAME -> ^( PARAM NAME ) ;
    public YaplParser.param_return param() // throws RecognitionException [1]
    {   
        YaplParser.param_return retval = new YaplParser.param_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken NAME59 = null;

        CommonTree NAME59_tree=null;
        RewriteRuleTokenStream stream_NAME = new RewriteRuleTokenStream(adaptor,"token NAME");

        try 
    	{
            // YaplParser.g:67:6: ( NAME -> ^( PARAM NAME ) )
            // YaplParser.g:67:8: NAME
            {
            	NAME59=(IToken)Match(input,NAME,FOLLOW_NAME_in_param481);  
            	stream_NAME.Add(NAME59);



            	// AST REWRITE
            	// elements:          NAME
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 67:13: -> ^( PARAM NAME )
            	{
            	    // YaplParser.g:67:16: ^( PARAM NAME )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(PARAM, "PARAM"), root_1);

            	    adaptor.AddChild(root_1, stream_NAME.NextNode());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "param"

    public class code_block_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "code_block"
    // YaplParser.g:68:1: code_block : ( statement terminator )* -> ^( CODE_BLOCK ( statement )* ) ;
    public YaplParser.code_block_return code_block() // throws RecognitionException [1]
    {   
        YaplParser.code_block_return retval = new YaplParser.code_block_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        YaplParser.statement_return statement60 = null;

        YaplParser.terminator_return terminator61 = null;


        RewriteRuleSubtreeStream stream_statement = new RewriteRuleSubtreeStream(adaptor,"rule statement");
        RewriteRuleSubtreeStream stream_terminator = new RewriteRuleSubtreeStream(adaptor,"rule terminator");
        try 
    	{
            // YaplParser.g:68:11: ( ( statement terminator )* -> ^( CODE_BLOCK ( statement )* ) )
            // YaplParser.g:68:13: ( statement terminator )*
            {
            	// YaplParser.g:68:13: ( statement terminator )*
            	do 
            	{
            	    int alt5 = 2;
            	    int LA5_0 = input.LA(1);

            	    if ( (LA5_0 == LEFT_PAREN || LA5_0 == FUNC || (LA5_0 >= RET && LA5_0 <= IF) || (LA5_0 >= DECREMENT && LA5_0 <= PLUS) || (LA5_0 >= NOT && LA5_0 <= BOOL_C) || (LA5_0 >= CLASS_NAME && LA5_0 <= NAME) || LA5_0 == INSTANCE_NAME || LA5_0 == STRING_LITERAL) )
            	    {
            	        alt5 = 1;
            	    }


            	    switch (alt5) 
            		{
            			case 1 :
            			    // YaplParser.g:68:14: statement terminator
            			    {
            			    	PushFollow(FOLLOW_statement_in_code_block496);
            			    	statement60 = statement();
            			    	state.followingStackPointer--;

            			    	stream_statement.Add(statement60.Tree);
            			    	PushFollow(FOLLOW_terminator_in_code_block498);
            			    	terminator61 = terminator();
            			    	state.followingStackPointer--;

            			    	stream_terminator.Add(terminator61.Tree);

            			    }
            			    break;

            			default:
            			    goto loop5;
            	    }
            	} while (true);

            	loop5:
            		;	// Stops C# compiler whining that label 'loop5' has no statements



            	// AST REWRITE
            	// elements:          statement
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 68:37: -> ^( CODE_BLOCK ( statement )* )
            	{
            	    // YaplParser.g:68:40: ^( CODE_BLOCK ( statement )* )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CODE_BLOCK, "CODE_BLOCK"), root_1);

            	    // YaplParser.g:68:53: ( statement )*
            	    while ( stream_statement.HasNext() )
            	    {
            	        adaptor.AddChild(root_1, stream_statement.NextTree());

            	    }
            	    stream_statement.Reset();

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "code_block"

    public class statement_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "statement"
    // YaplParser.g:70:1: statement : ( class_def | function | while_loop | if_statement | expression | return_stmt | assignment ) ;
    public YaplParser.statement_return statement() // throws RecognitionException [1]
    {   
        YaplParser.statement_return retval = new YaplParser.statement_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        YaplParser.class_def_return class_def62 = null;

        YaplParser.function_return function63 = null;

        YaplParser.while_loop_return while_loop64 = null;

        YaplParser.if_statement_return if_statement65 = null;

        YaplParser.expression_return expression66 = null;

        YaplParser.return_stmt_return return_stmt67 = null;

        YaplParser.assignment_return assignment68 = null;



        try 
    	{
            // YaplParser.g:70:10: ( ( class_def | function | while_loop | if_statement | expression | return_stmt | assignment ) )
            // YaplParser.g:70:12: ( class_def | function | while_loop | if_statement | expression | return_stmt | assignment )
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	// YaplParser.g:70:12: ( class_def | function | while_loop | if_statement | expression | return_stmt | assignment )
            	int alt6 = 7;
            	alt6 = dfa6.Predict(input);
            	switch (alt6) 
            	{
            	    case 1 :
            	        // YaplParser.g:70:13: class_def
            	        {
            	        	PushFollow(FOLLOW_class_def_in_statement517);
            	        	class_def62 = class_def();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, class_def62.Tree);

            	        }
            	        break;
            	    case 2 :
            	        // YaplParser.g:70:25: function
            	        {
            	        	PushFollow(FOLLOW_function_in_statement521);
            	        	function63 = function();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, function63.Tree);

            	        }
            	        break;
            	    case 3 :
            	        // YaplParser.g:70:36: while_loop
            	        {
            	        	PushFollow(FOLLOW_while_loop_in_statement525);
            	        	while_loop64 = while_loop();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, while_loop64.Tree);

            	        }
            	        break;
            	    case 4 :
            	        // YaplParser.g:70:49: if_statement
            	        {
            	        	PushFollow(FOLLOW_if_statement_in_statement529);
            	        	if_statement65 = if_statement();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, if_statement65.Tree);

            	        }
            	        break;
            	    case 5 :
            	        // YaplParser.g:70:64: expression
            	        {
            	        	PushFollow(FOLLOW_expression_in_statement533);
            	        	expression66 = expression();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, expression66.Tree);

            	        }
            	        break;
            	    case 6 :
            	        // YaplParser.g:70:77: return_stmt
            	        {
            	        	PushFollow(FOLLOW_return_stmt_in_statement537);
            	        	return_stmt67 = return_stmt();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, return_stmt67.Tree);

            	        }
            	        break;
            	    case 7 :
            	        // YaplParser.g:70:91: assignment
            	        {
            	        	PushFollow(FOLLOW_assignment_in_statement541);
            	        	assignment68 = assignment();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, assignment68.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "statement"

    public class expression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "expression"
    // YaplParser.g:71:1: expression : mult_expr ( ( PLUS | MINUS | OR ) mult_expr )* ;
    public YaplParser.expression_return expression() // throws RecognitionException [1]
    {   
        YaplParser.expression_return retval = new YaplParser.expression_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken set70 = null;
        YaplParser.mult_expr_return mult_expr69 = null;

        YaplParser.mult_expr_return mult_expr71 = null;


        CommonTree set70_tree=null;

        try 
    	{
            // YaplParser.g:71:11: ( mult_expr ( ( PLUS | MINUS | OR ) mult_expr )* )
            // YaplParser.g:71:13: mult_expr ( ( PLUS | MINUS | OR ) mult_expr )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_mult_expr_in_expression548);
            	mult_expr69 = mult_expr();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, mult_expr69.Tree);
            	// YaplParser.g:71:23: ( ( PLUS | MINUS | OR ) mult_expr )*
            	do 
            	{
            	    int alt7 = 2;
            	    int LA7_0 = input.LA(1);

            	    if ( ((LA7_0 >= MINUS && LA7_0 <= PLUS) || LA7_0 == OR) )
            	    {
            	        alt7 = 1;
            	    }


            	    switch (alt7) 
            		{
            			case 1 :
            			    // YaplParser.g:71:25: ( PLUS | MINUS | OR ) mult_expr
            			    {
            			    	set70=(IToken)input.LT(1);
            			    	set70 = (IToken)input.LT(1);
            			    	if ( (input.LA(1) >= MINUS && input.LA(1) <= PLUS) || input.LA(1) == OR ) 
            			    	{
            			    	    input.Consume();
            			    	    root_0 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(set70), root_0);
            			    	    state.errorRecovery = false;
            			    	}
            			    	else 
            			    	{
            			    	    MismatchedSetException mse = new MismatchedSetException(null,input);
            			    	    throw mse;
            			    	}

            			    	PushFollow(FOLLOW_mult_expr_in_expression565);
            			    	mult_expr71 = mult_expr();
            			    	state.followingStackPointer--;

            			    	adaptor.AddChild(root_0, mult_expr71.Tree);

            			    }
            			    break;

            			default:
            			    goto loop7;
            	    }
            	} while (true);

            	loop7:
            		;	// Stops C# compiler whining that label 'loop7' has no statements


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "expression"

    public class mult_expr_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "mult_expr"
    // YaplParser.g:72:1: mult_expr : primary ( ( MULTIPLY | DIVIDE | MOD | AND ) primary )* ;
    public YaplParser.mult_expr_return mult_expr() // throws RecognitionException [1]
    {   
        YaplParser.mult_expr_return retval = new YaplParser.mult_expr_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken set73 = null;
        YaplParser.primary_return primary72 = null;

        YaplParser.primary_return primary74 = null;


        CommonTree set73_tree=null;

        try 
    	{
            // YaplParser.g:72:10: ( primary ( ( MULTIPLY | DIVIDE | MOD | AND ) primary )* )
            // YaplParser.g:72:12: primary ( ( MULTIPLY | DIVIDE | MOD | AND ) primary )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_primary_in_mult_expr574);
            	primary72 = primary();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, primary72.Tree);
            	// YaplParser.g:72:20: ( ( MULTIPLY | DIVIDE | MOD | AND ) primary )*
            	do 
            	{
            	    int alt8 = 2;
            	    int LA8_0 = input.LA(1);

            	    if ( ((LA8_0 >= MULTIPLY && LA8_0 <= AND)) )
            	    {
            	        alt8 = 1;
            	    }


            	    switch (alt8) 
            		{
            			case 1 :
            			    // YaplParser.g:72:22: ( MULTIPLY | DIVIDE | MOD | AND ) primary
            			    {
            			    	set73=(IToken)input.LT(1);
            			    	set73 = (IToken)input.LT(1);
            			    	if ( (input.LA(1) >= MULTIPLY && input.LA(1) <= AND) ) 
            			    	{
            			    	    input.Consume();
            			    	    root_0 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(set73), root_0);
            			    	    state.errorRecovery = false;
            			    	}
            			    	else 
            			    	{
            			    	    MismatchedSetException mse = new MismatchedSetException(null,input);
            			    	    throw mse;
            			    	}

            			    	PushFollow(FOLLOW_primary_in_mult_expr595);
            			    	primary74 = primary();
            			    	state.followingStackPointer--;

            			    	adaptor.AddChild(root_0, primary74.Tree);

            			    }
            			    break;

            			default:
            			    goto loop8;
            	    }
            	} while (true);

            	loop8:
            		;	// Stops C# compiler whining that label 'loop8' has no statements


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "mult_expr"

    public class primary_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "primary"
    // YaplParser.g:73:1: primary : ( ( PLUS )? variable -> variable | ( PLUS )? instance_variable -> instance_variable | ( unary_operator ) variable -> ^( UNARY unary_operator variable ) | ( unary_operator ) instance_variable -> ^( UNARY unary_operator instance_variable ) | ( PLUS )? constant -> constant | ( unary_operator ) constant -> ^( UNARY unary_operator constant ) | ( PLUS )? func_call -> func_call | ( unary_operator ) func_call -> ^( UNARY unary_operator func_call ) | ( unary_operator ) LEFT_PAREN expression RIGHT_PAREN -> ^( UNARY unary_operator expression ) | LEFT_PAREN expression RIGHT_PAREN -> expression );
    public YaplParser.primary_return primary() // throws RecognitionException [1]
    {   
        YaplParser.primary_return retval = new YaplParser.primary_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken PLUS75 = null;
        IToken PLUS77 = null;
        IToken PLUS83 = null;
        IToken PLUS87 = null;
        IToken LEFT_PAREN92 = null;
        IToken RIGHT_PAREN94 = null;
        IToken LEFT_PAREN95 = null;
        IToken RIGHT_PAREN97 = null;
        YaplParser.variable_return variable76 = null;

        YaplParser.instance_variable_return instance_variable78 = null;

        YaplParser.unary_operator_return unary_operator79 = null;

        YaplParser.variable_return variable80 = null;

        YaplParser.unary_operator_return unary_operator81 = null;

        YaplParser.instance_variable_return instance_variable82 = null;

        YaplParser.constant_return constant84 = null;

        YaplParser.unary_operator_return unary_operator85 = null;

        YaplParser.constant_return constant86 = null;

        YaplParser.func_call_return func_call88 = null;

        YaplParser.unary_operator_return unary_operator89 = null;

        YaplParser.func_call_return func_call90 = null;

        YaplParser.unary_operator_return unary_operator91 = null;

        YaplParser.expression_return expression93 = null;

        YaplParser.expression_return expression96 = null;


        CommonTree PLUS75_tree=null;
        CommonTree PLUS77_tree=null;
        CommonTree PLUS83_tree=null;
        CommonTree PLUS87_tree=null;
        CommonTree LEFT_PAREN92_tree=null;
        CommonTree RIGHT_PAREN94_tree=null;
        CommonTree LEFT_PAREN95_tree=null;
        CommonTree RIGHT_PAREN97_tree=null;
        RewriteRuleTokenStream stream_LEFT_PAREN = new RewriteRuleTokenStream(adaptor,"token LEFT_PAREN");
        RewriteRuleTokenStream stream_RIGHT_PAREN = new RewriteRuleTokenStream(adaptor,"token RIGHT_PAREN");
        RewriteRuleTokenStream stream_PLUS = new RewriteRuleTokenStream(adaptor,"token PLUS");
        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor,"rule expression");
        RewriteRuleSubtreeStream stream_constant = new RewriteRuleSubtreeStream(adaptor,"rule constant");
        RewriteRuleSubtreeStream stream_func_call = new RewriteRuleSubtreeStream(adaptor,"rule func_call");
        RewriteRuleSubtreeStream stream_unary_operator = new RewriteRuleSubtreeStream(adaptor,"rule unary_operator");
        RewriteRuleSubtreeStream stream_instance_variable = new RewriteRuleSubtreeStream(adaptor,"rule instance_variable");
        RewriteRuleSubtreeStream stream_variable = new RewriteRuleSubtreeStream(adaptor,"rule variable");
        try 
    	{
            // YaplParser.g:73:8: ( ( PLUS )? variable -> variable | ( PLUS )? instance_variable -> instance_variable | ( unary_operator ) variable -> ^( UNARY unary_operator variable ) | ( unary_operator ) instance_variable -> ^( UNARY unary_operator instance_variable ) | ( PLUS )? constant -> constant | ( unary_operator ) constant -> ^( UNARY unary_operator constant ) | ( PLUS )? func_call -> func_call | ( unary_operator ) func_call -> ^( UNARY unary_operator func_call ) | ( unary_operator ) LEFT_PAREN expression RIGHT_PAREN -> ^( UNARY unary_operator expression ) | LEFT_PAREN expression RIGHT_PAREN -> expression )
            int alt13 = 10;
            alt13 = dfa13.Predict(input);
            switch (alt13) 
            {
                case 1 :
                    // YaplParser.g:74:5: ( PLUS )? variable
                    {
                    	// YaplParser.g:74:5: ( PLUS )?
                    	int alt9 = 2;
                    	int LA9_0 = input.LA(1);

                    	if ( (LA9_0 == PLUS) )
                    	{
                    	    alt9 = 1;
                    	}
                    	switch (alt9) 
                    	{
                    	    case 1 :
                    	        // YaplParser.g:74:5: PLUS
                    	        {
                    	        	PLUS75=(IToken)Match(input,PLUS,FOLLOW_PLUS_in_primary608);  
                    	        	stream_PLUS.Add(PLUS75);


                    	        }
                    	        break;

                    	}

                    	PushFollow(FOLLOW_variable_in_primary611);
                    	variable76 = variable();
                    	state.followingStackPointer--;

                    	stream_variable.Add(variable76.Tree);


                    	// AST REWRITE
                    	// elements:          variable
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 74:20: -> variable
                    	{
                    	    adaptor.AddChild(root_0, stream_variable.NextTree());

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;
                case 2 :
                    // YaplParser.g:75:5: ( PLUS )? instance_variable
                    {
                    	// YaplParser.g:75:5: ( PLUS )?
                    	int alt10 = 2;
                    	int LA10_0 = input.LA(1);

                    	if ( (LA10_0 == PLUS) )
                    	{
                    	    alt10 = 1;
                    	}
                    	switch (alt10) 
                    	{
                    	    case 1 :
                    	        // YaplParser.g:75:5: PLUS
                    	        {
                    	        	PLUS77=(IToken)Match(input,PLUS,FOLLOW_PLUS_in_primary621);  
                    	        	stream_PLUS.Add(PLUS77);


                    	        }
                    	        break;

                    	}

                    	PushFollow(FOLLOW_instance_variable_in_primary624);
                    	instance_variable78 = instance_variable();
                    	state.followingStackPointer--;

                    	stream_instance_variable.Add(instance_variable78.Tree);


                    	// AST REWRITE
                    	// elements:          instance_variable
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 75:29: -> instance_variable
                    	{
                    	    adaptor.AddChild(root_0, stream_instance_variable.NextTree());

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;
                case 3 :
                    // YaplParser.g:76:5: ( unary_operator ) variable
                    {
                    	// YaplParser.g:76:5: ( unary_operator )
                    	// YaplParser.g:76:6: unary_operator
                    	{
                    		PushFollow(FOLLOW_unary_operator_in_primary635);
                    		unary_operator79 = unary_operator();
                    		state.followingStackPointer--;

                    		stream_unary_operator.Add(unary_operator79.Tree);

                    	}

                    	PushFollow(FOLLOW_variable_in_primary638);
                    	variable80 = variable();
                    	state.followingStackPointer--;

                    	stream_variable.Add(variable80.Tree);


                    	// AST REWRITE
                    	// elements:          variable, unary_operator
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 76:31: -> ^( UNARY unary_operator variable )
                    	{
                    	    // YaplParser.g:76:34: ^( UNARY unary_operator variable )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(UNARY, "UNARY"), root_1);

                    	    adaptor.AddChild(root_1, stream_unary_operator.NextTree());
                    	    adaptor.AddChild(root_1, stream_variable.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;
                case 4 :
                    // YaplParser.g:77:5: ( unary_operator ) instance_variable
                    {
                    	// YaplParser.g:77:5: ( unary_operator )
                    	// YaplParser.g:77:6: unary_operator
                    	{
                    		PushFollow(FOLLOW_unary_operator_in_primary655);
                    		unary_operator81 = unary_operator();
                    		state.followingStackPointer--;

                    		stream_unary_operator.Add(unary_operator81.Tree);

                    	}

                    	PushFollow(FOLLOW_instance_variable_in_primary658);
                    	instance_variable82 = instance_variable();
                    	state.followingStackPointer--;

                    	stream_instance_variable.Add(instance_variable82.Tree);


                    	// AST REWRITE
                    	// elements:          instance_variable, unary_operator
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 77:40: -> ^( UNARY unary_operator instance_variable )
                    	{
                    	    // YaplParser.g:77:43: ^( UNARY unary_operator instance_variable )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(UNARY, "UNARY"), root_1);

                    	    adaptor.AddChild(root_1, stream_unary_operator.NextTree());
                    	    adaptor.AddChild(root_1, stream_instance_variable.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;
                case 5 :
                    // YaplParser.g:78:5: ( PLUS )? constant
                    {
                    	// YaplParser.g:78:5: ( PLUS )?
                    	int alt11 = 2;
                    	int LA11_0 = input.LA(1);

                    	if ( (LA11_0 == PLUS) )
                    	{
                    	    alt11 = 1;
                    	}
                    	switch (alt11) 
                    	{
                    	    case 1 :
                    	        // YaplParser.g:78:5: PLUS
                    	        {
                    	        	PLUS83=(IToken)Match(input,PLUS,FOLLOW_PLUS_in_primary674);  
                    	        	stream_PLUS.Add(PLUS83);


                    	        }
                    	        break;

                    	}

                    	PushFollow(FOLLOW_constant_in_primary677);
                    	constant84 = constant();
                    	state.followingStackPointer--;

                    	stream_constant.Add(constant84.Tree);


                    	// AST REWRITE
                    	// elements:          constant
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 78:20: -> constant
                    	{
                    	    adaptor.AddChild(root_0, stream_constant.NextTree());

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;
                case 6 :
                    // YaplParser.g:79:5: ( unary_operator ) constant
                    {
                    	// YaplParser.g:79:5: ( unary_operator )
                    	// YaplParser.g:79:6: unary_operator
                    	{
                    		PushFollow(FOLLOW_unary_operator_in_primary688);
                    		unary_operator85 = unary_operator();
                    		state.followingStackPointer--;

                    		stream_unary_operator.Add(unary_operator85.Tree);

                    	}

                    	PushFollow(FOLLOW_constant_in_primary691);
                    	constant86 = constant();
                    	state.followingStackPointer--;

                    	stream_constant.Add(constant86.Tree);


                    	// AST REWRITE
                    	// elements:          constant, unary_operator
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 79:31: -> ^( UNARY unary_operator constant )
                    	{
                    	    // YaplParser.g:79:34: ^( UNARY unary_operator constant )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(UNARY, "UNARY"), root_1);

                    	    adaptor.AddChild(root_1, stream_unary_operator.NextTree());
                    	    adaptor.AddChild(root_1, stream_constant.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;
                case 7 :
                    // YaplParser.g:80:5: ( PLUS )? func_call
                    {
                    	// YaplParser.g:80:5: ( PLUS )?
                    	int alt12 = 2;
                    	int LA12_0 = input.LA(1);

                    	if ( (LA12_0 == PLUS) )
                    	{
                    	    alt12 = 1;
                    	}
                    	switch (alt12) 
                    	{
                    	    case 1 :
                    	        // YaplParser.g:80:5: PLUS
                    	        {
                    	        	PLUS87=(IToken)Match(input,PLUS,FOLLOW_PLUS_in_primary707);  
                    	        	stream_PLUS.Add(PLUS87);


                    	        }
                    	        break;

                    	}

                    	PushFollow(FOLLOW_func_call_in_primary710);
                    	func_call88 = func_call();
                    	state.followingStackPointer--;

                    	stream_func_call.Add(func_call88.Tree);


                    	// AST REWRITE
                    	// elements:          func_call
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 80:21: -> func_call
                    	{
                    	    adaptor.AddChild(root_0, stream_func_call.NextTree());

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;
                case 8 :
                    // YaplParser.g:81:5: ( unary_operator ) func_call
                    {
                    	// YaplParser.g:81:5: ( unary_operator )
                    	// YaplParser.g:81:6: unary_operator
                    	{
                    		PushFollow(FOLLOW_unary_operator_in_primary720);
                    		unary_operator89 = unary_operator();
                    		state.followingStackPointer--;

                    		stream_unary_operator.Add(unary_operator89.Tree);

                    	}

                    	PushFollow(FOLLOW_func_call_in_primary723);
                    	func_call90 = func_call();
                    	state.followingStackPointer--;

                    	stream_func_call.Add(func_call90.Tree);


                    	// AST REWRITE
                    	// elements:          func_call, unary_operator
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 81:32: -> ^( UNARY unary_operator func_call )
                    	{
                    	    // YaplParser.g:81:35: ^( UNARY unary_operator func_call )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(UNARY, "UNARY"), root_1);

                    	    adaptor.AddChild(root_1, stream_unary_operator.NextTree());
                    	    adaptor.AddChild(root_1, stream_func_call.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;
                case 9 :
                    // YaplParser.g:82:5: ( unary_operator ) LEFT_PAREN expression RIGHT_PAREN
                    {
                    	// YaplParser.g:82:5: ( unary_operator )
                    	// YaplParser.g:82:6: unary_operator
                    	{
                    		PushFollow(FOLLOW_unary_operator_in_primary740);
                    		unary_operator91 = unary_operator();
                    		state.followingStackPointer--;

                    		stream_unary_operator.Add(unary_operator91.Tree);

                    	}

                    	LEFT_PAREN92=(IToken)Match(input,LEFT_PAREN,FOLLOW_LEFT_PAREN_in_primary743);  
                    	stream_LEFT_PAREN.Add(LEFT_PAREN92);

                    	PushFollow(FOLLOW_expression_in_primary745);
                    	expression93 = expression();
                    	state.followingStackPointer--;

                    	stream_expression.Add(expression93.Tree);
                    	RIGHT_PAREN94=(IToken)Match(input,RIGHT_PAREN,FOLLOW_RIGHT_PAREN_in_primary747);  
                    	stream_RIGHT_PAREN.Add(RIGHT_PAREN94);



                    	// AST REWRITE
                    	// elements:          unary_operator, expression
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 82:56: -> ^( UNARY unary_operator expression )
                    	{
                    	    // YaplParser.g:82:59: ^( UNARY unary_operator expression )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(UNARY, "UNARY"), root_1);

                    	    adaptor.AddChild(root_1, stream_unary_operator.NextTree());
                    	    adaptor.AddChild(root_1, stream_expression.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;
                case 10 :
                    // YaplParser.g:83:5: LEFT_PAREN expression RIGHT_PAREN
                    {
                    	LEFT_PAREN95=(IToken)Match(input,LEFT_PAREN,FOLLOW_LEFT_PAREN_in_primary763);  
                    	stream_LEFT_PAREN.Add(LEFT_PAREN95);

                    	PushFollow(FOLLOW_expression_in_primary765);
                    	expression96 = expression();
                    	state.followingStackPointer--;

                    	stream_expression.Add(expression96.Tree);
                    	RIGHT_PAREN97=(IToken)Match(input,RIGHT_PAREN,FOLLOW_RIGHT_PAREN_in_primary767);  
                    	stream_RIGHT_PAREN.Add(RIGHT_PAREN97);



                    	// AST REWRITE
                    	// elements:          expression
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 83:39: -> expression
                    	{
                    	    adaptor.AddChild(root_0, stream_expression.NextTree());

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "primary"

    public class unary_operator_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "unary_operator"
    // YaplParser.g:86:1: unary_operator : ( MINUS | INCREMENT | DECREMENT | NOT );
    public YaplParser.unary_operator_return unary_operator() // throws RecognitionException [1]
    {   
        YaplParser.unary_operator_return retval = new YaplParser.unary_operator_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken set98 = null;

        CommonTree set98_tree=null;

        try 
    	{
            // YaplParser.g:86:15: ( MINUS | INCREMENT | DECREMENT | NOT )
            // YaplParser.g:
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	set98 = (IToken)input.LT(1);
            	if ( (input.LA(1) >= DECREMENT && input.LA(1) <= MINUS) || input.LA(1) == NOT ) 
            	{
            	    input.Consume();
            	    adaptor.AddChild(root_0, (CommonTree)adaptor.Create(set98));
            	    state.errorRecovery = false;
            	}
            	else 
            	{
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "unary_operator"

    public class assignment_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "assignment"
    // YaplParser.g:88:1: assignment : ( variable ASSIGN expression -> ^( ASSIGNMENT variable expression ) | instance_variable ASSIGN expression -> ^( ASSIGNMENT instance_variable expression ) );
    public YaplParser.assignment_return assignment() // throws RecognitionException [1]
    {   
        YaplParser.assignment_return retval = new YaplParser.assignment_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken ASSIGN100 = null;
        IToken ASSIGN103 = null;
        YaplParser.variable_return variable99 = null;

        YaplParser.expression_return expression101 = null;

        YaplParser.instance_variable_return instance_variable102 = null;

        YaplParser.expression_return expression104 = null;


        CommonTree ASSIGN100_tree=null;
        CommonTree ASSIGN103_tree=null;
        RewriteRuleTokenStream stream_ASSIGN = new RewriteRuleTokenStream(adaptor,"token ASSIGN");
        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor,"rule expression");
        RewriteRuleSubtreeStream stream_instance_variable = new RewriteRuleSubtreeStream(adaptor,"rule instance_variable");
        RewriteRuleSubtreeStream stream_variable = new RewriteRuleSubtreeStream(adaptor,"rule variable");
        try 
    	{
            // YaplParser.g:88:11: ( variable ASSIGN expression -> ^( ASSIGNMENT variable expression ) | instance_variable ASSIGN expression -> ^( ASSIGNMENT instance_variable expression ) )
            int alt14 = 2;
            int LA14_0 = input.LA(1);

            if ( (LA14_0 == NAME) )
            {
                alt14 = 1;
            }
            else if ( (LA14_0 == INSTANCE_NAME) )
            {
                alt14 = 2;
            }
            else 
            {
                NoViableAltException nvae_d14s0 =
                    new NoViableAltException("", 14, 0, input);

                throw nvae_d14s0;
            }
            switch (alt14) 
            {
                case 1 :
                    // YaplParser.g:88:13: variable ASSIGN expression
                    {
                    	PushFollow(FOLLOW_variable_in_assignment799);
                    	variable99 = variable();
                    	state.followingStackPointer--;

                    	stream_variable.Add(variable99.Tree);
                    	ASSIGN100=(IToken)Match(input,ASSIGN,FOLLOW_ASSIGN_in_assignment801);  
                    	stream_ASSIGN.Add(ASSIGN100);

                    	PushFollow(FOLLOW_expression_in_assignment803);
                    	expression101 = expression();
                    	state.followingStackPointer--;

                    	stream_expression.Add(expression101.Tree);


                    	// AST REWRITE
                    	// elements:          variable, expression
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 88:40: -> ^( ASSIGNMENT variable expression )
                    	{
                    	    // YaplParser.g:88:43: ^( ASSIGNMENT variable expression )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(ASSIGNMENT, "ASSIGNMENT"), root_1);

                    	    adaptor.AddChild(root_1, stream_variable.NextTree());
                    	    adaptor.AddChild(root_1, stream_expression.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;
                case 2 :
                    // YaplParser.g:89:6: instance_variable ASSIGN expression
                    {
                    	PushFollow(FOLLOW_instance_variable_in_assignment820);
                    	instance_variable102 = instance_variable();
                    	state.followingStackPointer--;

                    	stream_instance_variable.Add(instance_variable102.Tree);
                    	ASSIGN103=(IToken)Match(input,ASSIGN,FOLLOW_ASSIGN_in_assignment822);  
                    	stream_ASSIGN.Add(ASSIGN103);

                    	PushFollow(FOLLOW_expression_in_assignment824);
                    	expression104 = expression();
                    	state.followingStackPointer--;

                    	stream_expression.Add(expression104.Tree);


                    	// AST REWRITE
                    	// elements:          expression, instance_variable
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 89:42: -> ^( ASSIGNMENT instance_variable expression )
                    	{
                    	    // YaplParser.g:89:45: ^( ASSIGNMENT instance_variable expression )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(ASSIGNMENT, "ASSIGNMENT"), root_1);

                    	    adaptor.AddChild(root_1, stream_instance_variable.NextTree());
                    	    adaptor.AddChild(root_1, stream_expression.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "assignment"

    public class variable_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "variable"
    // YaplParser.g:91:1: variable : NAME -> ^( VARIABLE NAME ) ;
    public YaplParser.variable_return variable() // throws RecognitionException [1]
    {   
        YaplParser.variable_return retval = new YaplParser.variable_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken NAME105 = null;

        CommonTree NAME105_tree=null;
        RewriteRuleTokenStream stream_NAME = new RewriteRuleTokenStream(adaptor,"token NAME");

        try 
    	{
            // YaplParser.g:91:9: ( NAME -> ^( VARIABLE NAME ) )
            // YaplParser.g:91:11: NAME
            {
            	NAME105=(IToken)Match(input,NAME,FOLLOW_NAME_in_variable844);  
            	stream_NAME.Add(NAME105);



            	// AST REWRITE
            	// elements:          NAME
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 91:16: -> ^( VARIABLE NAME )
            	{
            	    // YaplParser.g:91:19: ^( VARIABLE NAME )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(VARIABLE, "VARIABLE"), root_1);

            	    adaptor.AddChild(root_1, stream_NAME.NextNode());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "variable"

    public class instance_variable_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "instance_variable"
    // YaplParser.g:92:1: instance_variable : INSTANCE_NAME -> ^( INSTANCE_VARIABLE INSTANCE_NAME ) ;
    public YaplParser.instance_variable_return instance_variable() // throws RecognitionException [1]
    {   
        YaplParser.instance_variable_return retval = new YaplParser.instance_variable_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken INSTANCE_NAME106 = null;

        CommonTree INSTANCE_NAME106_tree=null;
        RewriteRuleTokenStream stream_INSTANCE_NAME = new RewriteRuleTokenStream(adaptor,"token INSTANCE_NAME");

        try 
    	{
            // YaplParser.g:92:18: ( INSTANCE_NAME -> ^( INSTANCE_VARIABLE INSTANCE_NAME ) )
            // YaplParser.g:92:20: INSTANCE_NAME
            {
            	INSTANCE_NAME106=(IToken)Match(input,INSTANCE_NAME,FOLLOW_INSTANCE_NAME_in_instance_variable858);  
            	stream_INSTANCE_NAME.Add(INSTANCE_NAME106);



            	// AST REWRITE
            	// elements:          INSTANCE_NAME
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 92:34: -> ^( INSTANCE_VARIABLE INSTANCE_NAME )
            	{
            	    // YaplParser.g:92:37: ^( INSTANCE_VARIABLE INSTANCE_NAME )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(INSTANCE_VARIABLE, "INSTANCE_VARIABLE"), root_1);

            	    adaptor.AddChild(root_1, stream_INSTANCE_NAME.NextNode());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "instance_variable"

    public class class_reference_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "class_reference"
    // YaplParser.g:93:1: class_reference : CLASS_NAME -> ^( CLASS_REFERENCE CLASS_NAME ) ;
    public YaplParser.class_reference_return class_reference() // throws RecognitionException [1]
    {   
        YaplParser.class_reference_return retval = new YaplParser.class_reference_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken CLASS_NAME107 = null;

        CommonTree CLASS_NAME107_tree=null;
        RewriteRuleTokenStream stream_CLASS_NAME = new RewriteRuleTokenStream(adaptor,"token CLASS_NAME");

        try 
    	{
            // YaplParser.g:93:16: ( CLASS_NAME -> ^( CLASS_REFERENCE CLASS_NAME ) )
            // YaplParser.g:93:18: CLASS_NAME
            {
            	CLASS_NAME107=(IToken)Match(input,CLASS_NAME,FOLLOW_CLASS_NAME_in_class_reference872);  
            	stream_CLASS_NAME.Add(CLASS_NAME107);



            	// AST REWRITE
            	// elements:          CLASS_NAME
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 93:29: -> ^( CLASS_REFERENCE CLASS_NAME )
            	{
            	    // YaplParser.g:93:32: ^( CLASS_REFERENCE CLASS_NAME )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CLASS_REFERENCE, "CLASS_REFERENCE"), root_1);

            	    adaptor.AddChild(root_1, stream_CLASS_NAME.NextNode());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "class_reference"

    public class func_call_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "func_call"
    // YaplParser.g:94:1: func_call : (fn= NAME LEFT_PAREN e= expr_list RIGHT_PAREN -> ^( FUNC_CALL $fn $e) | v= variable DOT fn= NAME LEFT_PAREN e= expr_list RIGHT_PAREN -> ^( EXPR_FUNC_CALL $fn $e $v) | cr= class_reference DOT fn= NAME LEFT_PAREN e= expr_list RIGHT_PAREN -> ^( CLASS_FUNC_CALL $fn $e $cr) | inst= instance_variable DOT fn= NAME LEFT_PAREN e= expr_list RIGHT_PAREN -> ^( INSTVAR_FUNC_CALL $fn $e $inst) );
    public YaplParser.func_call_return func_call() // throws RecognitionException [1]
    {   
        YaplParser.func_call_return retval = new YaplParser.func_call_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken fn = null;
        IToken LEFT_PAREN108 = null;
        IToken RIGHT_PAREN109 = null;
        IToken DOT110 = null;
        IToken LEFT_PAREN111 = null;
        IToken RIGHT_PAREN112 = null;
        IToken DOT113 = null;
        IToken LEFT_PAREN114 = null;
        IToken RIGHT_PAREN115 = null;
        IToken DOT116 = null;
        IToken LEFT_PAREN117 = null;
        IToken RIGHT_PAREN118 = null;
        YaplParser.expr_list_return e = null;

        YaplParser.variable_return v = null;

        YaplParser.class_reference_return cr = null;

        YaplParser.instance_variable_return inst = null;


        CommonTree fn_tree=null;
        CommonTree LEFT_PAREN108_tree=null;
        CommonTree RIGHT_PAREN109_tree=null;
        CommonTree DOT110_tree=null;
        CommonTree LEFT_PAREN111_tree=null;
        CommonTree RIGHT_PAREN112_tree=null;
        CommonTree DOT113_tree=null;
        CommonTree LEFT_PAREN114_tree=null;
        CommonTree RIGHT_PAREN115_tree=null;
        CommonTree DOT116_tree=null;
        CommonTree LEFT_PAREN117_tree=null;
        CommonTree RIGHT_PAREN118_tree=null;
        RewriteRuleTokenStream stream_LEFT_PAREN = new RewriteRuleTokenStream(adaptor,"token LEFT_PAREN");
        RewriteRuleTokenStream stream_RIGHT_PAREN = new RewriteRuleTokenStream(adaptor,"token RIGHT_PAREN");
        RewriteRuleTokenStream stream_NAME = new RewriteRuleTokenStream(adaptor,"token NAME");
        RewriteRuleTokenStream stream_DOT = new RewriteRuleTokenStream(adaptor,"token DOT");
        RewriteRuleSubtreeStream stream_class_reference = new RewriteRuleSubtreeStream(adaptor,"rule class_reference");
        RewriteRuleSubtreeStream stream_instance_variable = new RewriteRuleSubtreeStream(adaptor,"rule instance_variable");
        RewriteRuleSubtreeStream stream_variable = new RewriteRuleSubtreeStream(adaptor,"rule variable");
        RewriteRuleSubtreeStream stream_expr_list = new RewriteRuleSubtreeStream(adaptor,"rule expr_list");
        try 
    	{
            // YaplParser.g:94:10: (fn= NAME LEFT_PAREN e= expr_list RIGHT_PAREN -> ^( FUNC_CALL $fn $e) | v= variable DOT fn= NAME LEFT_PAREN e= expr_list RIGHT_PAREN -> ^( EXPR_FUNC_CALL $fn $e $v) | cr= class_reference DOT fn= NAME LEFT_PAREN e= expr_list RIGHT_PAREN -> ^( CLASS_FUNC_CALL $fn $e $cr) | inst= instance_variable DOT fn= NAME LEFT_PAREN e= expr_list RIGHT_PAREN -> ^( INSTVAR_FUNC_CALL $fn $e $inst) )
            int alt15 = 4;
            switch ( input.LA(1) ) 
            {
            case NAME:
            	{
                int LA15_1 = input.LA(2);

                if ( (LA15_1 == LEFT_PAREN) )
                {
                    alt15 = 1;
                }
                else if ( (LA15_1 == DOT) )
                {
                    alt15 = 2;
                }
                else 
                {
                    NoViableAltException nvae_d15s1 =
                        new NoViableAltException("", 15, 1, input);

                    throw nvae_d15s1;
                }
                }
                break;
            case CLASS_NAME:
            	{
                alt15 = 3;
                }
                break;
            case INSTANCE_NAME:
            	{
                alt15 = 4;
                }
                break;
            	default:
            	    NoViableAltException nvae_d15s0 =
            	        new NoViableAltException("", 15, 0, input);

            	    throw nvae_d15s0;
            }

            switch (alt15) 
            {
                case 1 :
                    // YaplParser.g:94:12: fn= NAME LEFT_PAREN e= expr_list RIGHT_PAREN
                    {
                    	fn=(IToken)Match(input,NAME,FOLLOW_NAME_in_func_call888);  
                    	stream_NAME.Add(fn);

                    	LEFT_PAREN108=(IToken)Match(input,LEFT_PAREN,FOLLOW_LEFT_PAREN_in_func_call890);  
                    	stream_LEFT_PAREN.Add(LEFT_PAREN108);

                    	PushFollow(FOLLOW_expr_list_in_func_call894);
                    	e = expr_list();
                    	state.followingStackPointer--;

                    	stream_expr_list.Add(e.Tree);
                    	RIGHT_PAREN109=(IToken)Match(input,RIGHT_PAREN,FOLLOW_RIGHT_PAREN_in_func_call896);  
                    	stream_RIGHT_PAREN.Add(RIGHT_PAREN109);



                    	// AST REWRITE
                    	// elements:          fn, e
                    	// token labels:      fn
                    	// rule labels:       retval, e
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleTokenStream stream_fn = new RewriteRuleTokenStream(adaptor, "token fn", fn);
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
                    	RewriteRuleSubtreeStream stream_e = new RewriteRuleSubtreeStream(adaptor, "rule e", e!=null ? e.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 94:55: -> ^( FUNC_CALL $fn $e)
                    	{
                    	    // YaplParser.g:94:58: ^( FUNC_CALL $fn $e)
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(FUNC_CALL, "FUNC_CALL"), root_1);

                    	    adaptor.AddChild(root_1, stream_fn.NextNode());
                    	    adaptor.AddChild(root_1, stream_e.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;
                case 2 :
                    // YaplParser.g:95:4: v= variable DOT fn= NAME LEFT_PAREN e= expr_list RIGHT_PAREN
                    {
                    	PushFollow(FOLLOW_variable_in_func_call915);
                    	v = variable();
                    	state.followingStackPointer--;

                    	stream_variable.Add(v.Tree);
                    	DOT110=(IToken)Match(input,DOT,FOLLOW_DOT_in_func_call917);  
                    	stream_DOT.Add(DOT110);

                    	fn=(IToken)Match(input,NAME,FOLLOW_NAME_in_func_call921);  
                    	stream_NAME.Add(fn);

                    	LEFT_PAREN111=(IToken)Match(input,LEFT_PAREN,FOLLOW_LEFT_PAREN_in_func_call923);  
                    	stream_LEFT_PAREN.Add(LEFT_PAREN111);

                    	PushFollow(FOLLOW_expr_list_in_func_call927);
                    	e = expr_list();
                    	state.followingStackPointer--;

                    	stream_expr_list.Add(e.Tree);
                    	RIGHT_PAREN112=(IToken)Match(input,RIGHT_PAREN,FOLLOW_RIGHT_PAREN_in_func_call929);  
                    	stream_RIGHT_PAREN.Add(RIGHT_PAREN112);



                    	// AST REWRITE
                    	// elements:          fn, v, e
                    	// token labels:      fn
                    	// rule labels:       v, retval, e
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleTokenStream stream_fn = new RewriteRuleTokenStream(adaptor, "token fn", fn);
                    	RewriteRuleSubtreeStream stream_v = new RewriteRuleSubtreeStream(adaptor, "rule v", v!=null ? v.Tree : null);
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
                    	RewriteRuleSubtreeStream stream_e = new RewriteRuleSubtreeStream(adaptor, "rule e", e!=null ? e.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 95:62: -> ^( EXPR_FUNC_CALL $fn $e $v)
                    	{
                    	    // YaplParser.g:95:65: ^( EXPR_FUNC_CALL $fn $e $v)
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(EXPR_FUNC_CALL, "EXPR_FUNC_CALL"), root_1);

                    	    adaptor.AddChild(root_1, stream_fn.NextNode());
                    	    adaptor.AddChild(root_1, stream_e.NextTree());
                    	    adaptor.AddChild(root_1, stream_v.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;
                case 3 :
                    // YaplParser.g:96:4: cr= class_reference DOT fn= NAME LEFT_PAREN e= expr_list RIGHT_PAREN
                    {
                    	PushFollow(FOLLOW_class_reference_in_func_call951);
                    	cr = class_reference();
                    	state.followingStackPointer--;

                    	stream_class_reference.Add(cr.Tree);
                    	DOT113=(IToken)Match(input,DOT,FOLLOW_DOT_in_func_call953);  
                    	stream_DOT.Add(DOT113);

                    	fn=(IToken)Match(input,NAME,FOLLOW_NAME_in_func_call957);  
                    	stream_NAME.Add(fn);

                    	LEFT_PAREN114=(IToken)Match(input,LEFT_PAREN,FOLLOW_LEFT_PAREN_in_func_call959);  
                    	stream_LEFT_PAREN.Add(LEFT_PAREN114);

                    	PushFollow(FOLLOW_expr_list_in_func_call963);
                    	e = expr_list();
                    	state.followingStackPointer--;

                    	stream_expr_list.Add(e.Tree);
                    	RIGHT_PAREN115=(IToken)Match(input,RIGHT_PAREN,FOLLOW_RIGHT_PAREN_in_func_call965);  
                    	stream_RIGHT_PAREN.Add(RIGHT_PAREN115);



                    	// AST REWRITE
                    	// elements:          cr, e, fn
                    	// token labels:      fn
                    	// rule labels:       cr, retval, e
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleTokenStream stream_fn = new RewriteRuleTokenStream(adaptor, "token fn", fn);
                    	RewriteRuleSubtreeStream stream_cr = new RewriteRuleSubtreeStream(adaptor, "rule cr", cr!=null ? cr.Tree : null);
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
                    	RewriteRuleSubtreeStream stream_e = new RewriteRuleSubtreeStream(adaptor, "rule e", e!=null ? e.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 96:70: -> ^( CLASS_FUNC_CALL $fn $e $cr)
                    	{
                    	    // YaplParser.g:96:73: ^( CLASS_FUNC_CALL $fn $e $cr)
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CLASS_FUNC_CALL, "CLASS_FUNC_CALL"), root_1);

                    	    adaptor.AddChild(root_1, stream_fn.NextNode());
                    	    adaptor.AddChild(root_1, stream_e.NextTree());
                    	    adaptor.AddChild(root_1, stream_cr.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;
                case 4 :
                    // YaplParser.g:97:4: inst= instance_variable DOT fn= NAME LEFT_PAREN e= expr_list RIGHT_PAREN
                    {
                    	PushFollow(FOLLOW_instance_variable_in_func_call987);
                    	inst = instance_variable();
                    	state.followingStackPointer--;

                    	stream_instance_variable.Add(inst.Tree);
                    	DOT116=(IToken)Match(input,DOT,FOLLOW_DOT_in_func_call989);  
                    	stream_DOT.Add(DOT116);

                    	fn=(IToken)Match(input,NAME,FOLLOW_NAME_in_func_call993);  
                    	stream_NAME.Add(fn);

                    	LEFT_PAREN117=(IToken)Match(input,LEFT_PAREN,FOLLOW_LEFT_PAREN_in_func_call995);  
                    	stream_LEFT_PAREN.Add(LEFT_PAREN117);

                    	PushFollow(FOLLOW_expr_list_in_func_call999);
                    	e = expr_list();
                    	state.followingStackPointer--;

                    	stream_expr_list.Add(e.Tree);
                    	RIGHT_PAREN118=(IToken)Match(input,RIGHT_PAREN,FOLLOW_RIGHT_PAREN_in_func_call1001);  
                    	stream_RIGHT_PAREN.Add(RIGHT_PAREN118);



                    	// AST REWRITE
                    	// elements:          inst, fn, e
                    	// token labels:      fn
                    	// rule labels:       retval, e, inst
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleTokenStream stream_fn = new RewriteRuleTokenStream(adaptor, "token fn", fn);
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
                    	RewriteRuleSubtreeStream stream_e = new RewriteRuleSubtreeStream(adaptor, "rule e", e!=null ? e.Tree : null);
                    	RewriteRuleSubtreeStream stream_inst = new RewriteRuleSubtreeStream(adaptor, "rule inst", inst!=null ? inst.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 97:74: -> ^( INSTVAR_FUNC_CALL $fn $e $inst)
                    	{
                    	    // YaplParser.g:97:77: ^( INSTVAR_FUNC_CALL $fn $e $inst)
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(INSTVAR_FUNC_CALL, "INSTVAR_FUNC_CALL"), root_1);

                    	    adaptor.AddChild(root_1, stream_fn.NextNode());
                    	    adaptor.AddChild(root_1, stream_e.NextTree());
                    	    adaptor.AddChild(root_1, stream_inst.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "func_call"

    public class expr_list_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "expr_list"
    // YaplParser.g:100:1: expr_list : ( expression ( COMMA expression )* )? -> ^( EXPR_LIST ( expression )* ) ;
    public YaplParser.expr_list_return expr_list() // throws RecognitionException [1]
    {   
        YaplParser.expr_list_return retval = new YaplParser.expr_list_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken COMMA120 = null;
        YaplParser.expression_return expression119 = null;

        YaplParser.expression_return expression121 = null;


        CommonTree COMMA120_tree=null;
        RewriteRuleTokenStream stream_COMMA = new RewriteRuleTokenStream(adaptor,"token COMMA");
        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor,"rule expression");
        try 
    	{
            // YaplParser.g:100:10: ( ( expression ( COMMA expression )* )? -> ^( EXPR_LIST ( expression )* ) )
            // YaplParser.g:100:12: ( expression ( COMMA expression )* )?
            {
            	// YaplParser.g:100:12: ( expression ( COMMA expression )* )?
            	int alt17 = 2;
            	int LA17_0 = input.LA(1);

            	if ( (LA17_0 == LEFT_PAREN || (LA17_0 >= DECREMENT && LA17_0 <= PLUS) || (LA17_0 >= NOT && LA17_0 <= BOOL_C) || (LA17_0 >= CLASS_NAME && LA17_0 <= NAME) || LA17_0 == INSTANCE_NAME || LA17_0 == STRING_LITERAL) )
            	{
            	    alt17 = 1;
            	}
            	switch (alt17) 
            	{
            	    case 1 :
            	        // YaplParser.g:100:13: expression ( COMMA expression )*
            	        {
            	        	PushFollow(FOLLOW_expression_in_expr_list1026);
            	        	expression119 = expression();
            	        	state.followingStackPointer--;

            	        	stream_expression.Add(expression119.Tree);
            	        	// YaplParser.g:100:24: ( COMMA expression )*
            	        	do 
            	        	{
            	        	    int alt16 = 2;
            	        	    int LA16_0 = input.LA(1);

            	        	    if ( (LA16_0 == COMMA) )
            	        	    {
            	        	        alt16 = 1;
            	        	    }


            	        	    switch (alt16) 
            	        		{
            	        			case 1 :
            	        			    // YaplParser.g:100:25: COMMA expression
            	        			    {
            	        			    	COMMA120=(IToken)Match(input,COMMA,FOLLOW_COMMA_in_expr_list1029);  
            	        			    	stream_COMMA.Add(COMMA120);

            	        			    	PushFollow(FOLLOW_expression_in_expr_list1031);
            	        			    	expression121 = expression();
            	        			    	state.followingStackPointer--;

            	        			    	stream_expression.Add(expression121.Tree);

            	        			    }
            	        			    break;

            	        			default:
            	        			    goto loop16;
            	        	    }
            	        	} while (true);

            	        	loop16:
            	        		;	// Stops C# compiler whining that label 'loop16' has no statements


            	        }
            	        break;

            	}



            	// AST REWRITE
            	// elements:          expression
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 100:46: -> ^( EXPR_LIST ( expression )* )
            	{
            	    // YaplParser.g:100:49: ^( EXPR_LIST ( expression )* )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(EXPR_LIST, "EXPR_LIST"), root_1);

            	    // YaplParser.g:100:61: ( expression )*
            	    while ( stream_expression.HasNext() )
            	    {
            	        adaptor.AddChild(root_1, stream_expression.NextTree());

            	    }
            	    stream_expression.Reset();

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "expr_list"

    public class return_stmt_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "return_stmt"
    // YaplParser.g:102:1: return_stmt : RET expression -> ^( RETURN expression ) ;
    public YaplParser.return_stmt_return return_stmt() // throws RecognitionException [1]
    {   
        YaplParser.return_stmt_return retval = new YaplParser.return_stmt_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken RET122 = null;
        YaplParser.expression_return expression123 = null;


        CommonTree RET122_tree=null;
        RewriteRuleTokenStream stream_RET = new RewriteRuleTokenStream(adaptor,"token RET");
        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor,"rule expression");
        try 
    	{
            // YaplParser.g:102:12: ( RET expression -> ^( RETURN expression ) )
            // YaplParser.g:102:14: RET expression
            {
            	RET122=(IToken)Match(input,RET,FOLLOW_RET_in_return_stmt1051);  
            	stream_RET.Add(RET122);

            	PushFollow(FOLLOW_expression_in_return_stmt1053);
            	expression123 = expression();
            	state.followingStackPointer--;

            	stream_expression.Add(expression123.Tree);


            	// AST REWRITE
            	// elements:          expression
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 102:29: -> ^( RETURN expression )
            	{
            	    // YaplParser.g:102:32: ^( RETURN expression )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(RETURN, "RETURN"), root_1);

            	    adaptor.AddChild(root_1, stream_expression.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "return_stmt"

    public class terminator_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "terminator"
    // YaplParser.g:103:1: terminator : ( newlines | EOF );
    public YaplParser.terminator_return terminator() // throws RecognitionException [1]
    {   
        YaplParser.terminator_return retval = new YaplParser.terminator_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken EOF125 = null;
        YaplParser.newlines_return newlines124 = null;


        CommonTree EOF125_tree=null;

        try 
    	{
            // YaplParser.g:103:11: ( newlines | EOF )
            int alt18 = 2;
            int LA18_0 = input.LA(1);

            if ( (LA18_0 == NEWLINE) )
            {
                alt18 = 1;
            }
            else if ( (LA18_0 == EOF) )
            {
                alt18 = 2;
            }
            else 
            {
                NoViableAltException nvae_d18s0 =
                    new NoViableAltException("", 18, 0, input);

                throw nvae_d18s0;
            }
            switch (alt18) 
            {
                case 1 :
                    // YaplParser.g:103:13: newlines
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_newlines_in_terminator1067);
                    	newlines124 = newlines();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, newlines124.Tree);

                    }
                    break;
                case 2 :
                    // YaplParser.g:103:24: EOF
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	EOF125=(IToken)Match(input,EOF,FOLLOW_EOF_in_terminator1071); 
                    		EOF125_tree = (CommonTree)adaptor.Create(EOF125);
                    		adaptor.AddChild(root_0, EOF125_tree);


                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "terminator"

    public class constant_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "constant"
    // YaplParser.g:105:1: constant : ( STRING_LITERAL -> ^( STRING_CONSTANT STRING_LITERAL ) | INTEGER -> ^( INT_CONSTANT INTEGER ) | FLOAT -> ^( FLOAT_CONSTANT FLOAT ) | BOOL_C -> ^( BOOL_CONSTANT BOOL_C ) );
    public YaplParser.constant_return constant() // throws RecognitionException [1]
    {   
        YaplParser.constant_return retval = new YaplParser.constant_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken STRING_LITERAL126 = null;
        IToken INTEGER127 = null;
        IToken FLOAT128 = null;
        IToken BOOL_C129 = null;

        CommonTree STRING_LITERAL126_tree=null;
        CommonTree INTEGER127_tree=null;
        CommonTree FLOAT128_tree=null;
        CommonTree BOOL_C129_tree=null;
        RewriteRuleTokenStream stream_INTEGER = new RewriteRuleTokenStream(adaptor,"token INTEGER");
        RewriteRuleTokenStream stream_BOOL_C = new RewriteRuleTokenStream(adaptor,"token BOOL_C");
        RewriteRuleTokenStream stream_FLOAT = new RewriteRuleTokenStream(adaptor,"token FLOAT");
        RewriteRuleTokenStream stream_STRING_LITERAL = new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL");

        try 
    	{
            // YaplParser.g:105:9: ( STRING_LITERAL -> ^( STRING_CONSTANT STRING_LITERAL ) | INTEGER -> ^( INT_CONSTANT INTEGER ) | FLOAT -> ^( FLOAT_CONSTANT FLOAT ) | BOOL_C -> ^( BOOL_CONSTANT BOOL_C ) )
            int alt19 = 4;
            switch ( input.LA(1) ) 
            {
            case STRING_LITERAL:
            	{
                alt19 = 1;
                }
                break;
            case INTEGER:
            	{
                alt19 = 2;
                }
                break;
            case FLOAT:
            	{
                alt19 = 3;
                }
                break;
            case BOOL_C:
            	{
                alt19 = 4;
                }
                break;
            	default:
            	    NoViableAltException nvae_d19s0 =
            	        new NoViableAltException("", 19, 0, input);

            	    throw nvae_d19s0;
            }

            switch (alt19) 
            {
                case 1 :
                    // YaplParser.g:105:11: STRING_LITERAL
                    {
                    	STRING_LITERAL126=(IToken)Match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_constant1078);  
                    	stream_STRING_LITERAL.Add(STRING_LITERAL126);



                    	// AST REWRITE
                    	// elements:          STRING_LITERAL
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 105:26: -> ^( STRING_CONSTANT STRING_LITERAL )
                    	{
                    	    // YaplParser.g:105:29: ^( STRING_CONSTANT STRING_LITERAL )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(STRING_CONSTANT, "STRING_CONSTANT"), root_1);

                    	    adaptor.AddChild(root_1, stream_STRING_LITERAL.NextNode());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;
                case 2 :
                    // YaplParser.g:106:5: INTEGER
                    {
                    	INTEGER127=(IToken)Match(input,INTEGER,FOLLOW_INTEGER_in_constant1092);  
                    	stream_INTEGER.Add(INTEGER127);



                    	// AST REWRITE
                    	// elements:          INTEGER
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 106:13: -> ^( INT_CONSTANT INTEGER )
                    	{
                    	    // YaplParser.g:106:16: ^( INT_CONSTANT INTEGER )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(INT_CONSTANT, "INT_CONSTANT"), root_1);

                    	    adaptor.AddChild(root_1, stream_INTEGER.NextNode());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;
                case 3 :
                    // YaplParser.g:107:5: FLOAT
                    {
                    	FLOAT128=(IToken)Match(input,FLOAT,FOLLOW_FLOAT_in_constant1106);  
                    	stream_FLOAT.Add(FLOAT128);



                    	// AST REWRITE
                    	// elements:          FLOAT
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 107:11: -> ^( FLOAT_CONSTANT FLOAT )
                    	{
                    	    // YaplParser.g:107:14: ^( FLOAT_CONSTANT FLOAT )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(FLOAT_CONSTANT, "FLOAT_CONSTANT"), root_1);

                    	    adaptor.AddChild(root_1, stream_FLOAT.NextNode());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;
                case 4 :
                    // YaplParser.g:108:5: BOOL_C
                    {
                    	BOOL_C129=(IToken)Match(input,BOOL_C,FOLLOW_BOOL_C_in_constant1120);  
                    	stream_BOOL_C.Add(BOOL_C129);



                    	// AST REWRITE
                    	// elements:          BOOL_C
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 108:12: -> ^( BOOL_CONSTANT BOOL_C )
                    	{
                    	    // YaplParser.g:108:15: ^( BOOL_CONSTANT BOOL_C )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(BOOL_CONSTANT, "BOOL_CONSTANT"), root_1);

                    	    adaptor.AddChild(root_1, stream_BOOL_C.NextNode());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "constant"

    public class newlines_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "newlines"
    // YaplParser.g:110:1: newlines : ( NEWLINE )+ ;
    public YaplParser.newlines_return newlines() // throws RecognitionException [1]
    {   
        YaplParser.newlines_return retval = new YaplParser.newlines_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken NEWLINE130 = null;

        CommonTree NEWLINE130_tree=null;

        try 
    	{
            // YaplParser.g:110:9: ( ( NEWLINE )+ )
            // YaplParser.g:110:11: ( NEWLINE )+
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	// YaplParser.g:110:11: ( NEWLINE )+
            	int cnt20 = 0;
            	do 
            	{
            	    int alt20 = 2;
            	    int LA20_0 = input.LA(1);

            	    if ( (LA20_0 == NEWLINE) )
            	    {
            	        alt20 = 1;
            	    }


            	    switch (alt20) 
            		{
            			case 1 :
            			    // YaplParser.g:110:11: NEWLINE
            			    {
            			    	NEWLINE130=(IToken)Match(input,NEWLINE,FOLLOW_NEWLINE_in_newlines1135); 
            			    		NEWLINE130_tree = (CommonTree)adaptor.Create(NEWLINE130);
            			    		adaptor.AddChild(root_0, NEWLINE130_tree);


            			    }
            			    break;

            			default:
            			    if ( cnt20 >= 1 ) goto loop20;
            		            EarlyExitException eee20 =
            		                new EarlyExitException(20, input);
            		            throw eee20;
            	    }
            	    cnt20++;
            	} while (true);

            	loop20:
            		;	// Stops C# compiler whining that label 'loop20' has no statements


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "newlines"

    // Delegated rules


   	protected DFA6 dfa6;
   	protected DFA13 dfa13;
	private void InitializeCyclicDFAs()
	{
    	this.dfa6 = new DFA6(this);
    	this.dfa13 = new DFA13(this);


	}

    const string DFA6_eotS =
        "\x0a\uffff";
    const string DFA6_eofS =
        "\x06\uffff\x02\x05\x02\uffff";
    const string DFA6_minS =
        "\x01\x05\x05\uffff\x02\x04\x02\uffff";
    const string DFA6_maxS =
        "\x01\x29\x05\uffff\x02\x2e\x02\uffff";
    const string DFA6_acceptS =
        "\x01\uffff\x01\x01\x01\x02\x01\x03\x01\x04\x01\x05\x02\uffff\x01"+
        "\x06\x01\x07";
    const string DFA6_specialS =
        "\x0a\uffff}>";
    static readonly string[] DFA6_transitionS = {
            "\x01\x05\x03\uffff\x01\x02\x01\uffff\x01\x08\x01\x01\x01\x03"+
            "\x01\x04\x05\uffff\x04\x05\x05\uffff\x04\x05\x03\uffff\x01\x05"+
            "\x01\x06\x01\uffff\x01\x07\x01\uffff\x01\x05",
            "",
            "",
            "",
            "",
            "",
            "\x01\x09\x01\x05\x0d\uffff\x01\x05\x02\uffff\x07\x05\x11\uffff"+
            "\x01\x05",
            "\x01\x09\x0e\uffff\x01\x05\x02\uffff\x07\x05\x11\uffff\x01"+
            "\x05",
            "",
            ""
    };

    static readonly short[] DFA6_eot = DFA.UnpackEncodedString(DFA6_eotS);
    static readonly short[] DFA6_eof = DFA.UnpackEncodedString(DFA6_eofS);
    static readonly char[] DFA6_min = DFA.UnpackEncodedStringToUnsignedChars(DFA6_minS);
    static readonly char[] DFA6_max = DFA.UnpackEncodedStringToUnsignedChars(DFA6_maxS);
    static readonly short[] DFA6_accept = DFA.UnpackEncodedString(DFA6_acceptS);
    static readonly short[] DFA6_special = DFA.UnpackEncodedString(DFA6_specialS);
    static readonly short[][] DFA6_transition = DFA.UnpackEncodedStringArray(DFA6_transitionS);

    protected class DFA6 : DFA
    {
        public DFA6(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 6;
            this.eot = DFA6_eot;
            this.eof = DFA6_eof;
            this.min = DFA6_min;
            this.max = DFA6_max;
            this.accept = DFA6_accept;
            this.special = DFA6_special;
            this.transition = DFA6_transition;

        }

        override public string Description
        {
            get { return "70:12: ( class_def | function | while_loop | if_statement | expression | return_stmt | assignment )"; }
        }

    }

    const string DFA13_eotS =
        "\x11\uffff";
    const string DFA13_eofS =
        "\x02\uffff\x01\x08\x01\x09\x06\uffff\x01\x0f\x01\x10\x05\uffff";
    const string DFA13_minS =
        "\x01\x05\x01\x1e\x01\x05\x01\x06\x01\x05\x05\uffff\x01\x06\x01"+
        "\x05\x05\uffff";
    const string DFA13_maxS =
        "\x02\x29\x02\x2e\x01\x29\x05\uffff\x02\x2e\x05\uffff";
    const string DFA13_acceptS =
        "\x05\uffff\x01\x05\x01\x07\x01\x0a\x01\x01\x01\x02\x02\uffff\x01"+
        "\x08\x01\x06\x01\x09\x01\x04\x01\x03";
    const string DFA13_specialS =
        "\x11\uffff}>";
    static readonly string[] DFA13_transitionS = {
            "\x01\x07\x0e\uffff\x03\x04\x01\x01\x05\uffff\x01\x04\x03\x05"+
            "\x03\uffff\x01\x06\x01\x02\x01\uffff\x01\x03\x01\uffff\x01\x05",
            "\x03\x05\x03\uffff\x01\x06\x01\x02\x01\uffff\x01\x03\x01\uffff"+
            "\x01\x05",
            "\x01\x06\x01\x08\x0b\uffff\x01\x08\x01\x06\x02\uffff\x07\x08"+
            "\x11\uffff\x01\x08",
            "\x01\x09\x0b\uffff\x01\x09\x01\x06\x02\uffff\x07\x09\x11\uffff"+
            "\x01\x09",
            "\x01\x0e\x18\uffff\x03\x0d\x03\uffff\x01\x0c\x01\x0b\x01\uffff"+
            "\x01\x0a\x01\uffff\x01\x0d",
            "",
            "",
            "",
            "",
            "",
            "\x01\x0f\x0b\uffff\x01\x0f\x01\x0c\x02\uffff\x07\x0f\x11\uffff"+
            "\x01\x0f",
            "\x01\x0c\x01\x10\x0b\uffff\x01\x10\x01\x0c\x02\uffff\x07\x10"+
            "\x11\uffff\x01\x10",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA13_eot = DFA.UnpackEncodedString(DFA13_eotS);
    static readonly short[] DFA13_eof = DFA.UnpackEncodedString(DFA13_eofS);
    static readonly char[] DFA13_min = DFA.UnpackEncodedStringToUnsignedChars(DFA13_minS);
    static readonly char[] DFA13_max = DFA.UnpackEncodedStringToUnsignedChars(DFA13_maxS);
    static readonly short[] DFA13_accept = DFA.UnpackEncodedString(DFA13_acceptS);
    static readonly short[] DFA13_special = DFA.UnpackEncodedString(DFA13_specialS);
    static readonly short[][] DFA13_transition = DFA.UnpackEncodedStringArray(DFA13_transitionS);

    protected class DFA13 : DFA
    {
        public DFA13(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 13;
            this.eot = DFA13_eot;
            this.eof = DFA13_eof;
            this.min = DFA13_min;
            this.max = DFA13_max;
            this.accept = DFA13_accept;
            this.special = DFA13_special;
            this.transition = DFA13_transition;

        }

        override public string Description
        {
            get { return "73:1: primary : ( ( PLUS )? variable -> variable | ( PLUS )? instance_variable -> instance_variable | ( unary_operator ) variable -> ^( UNARY unary_operator variable ) | ( unary_operator ) instance_variable -> ^( UNARY unary_operator instance_variable ) | ( PLUS )? constant -> constant | ( unary_operator ) constant -> ^( UNARY unary_operator constant ) | ( PLUS )? func_call -> func_call | ( unary_operator ) func_call -> ^( UNARY unary_operator func_call ) | ( unary_operator ) LEFT_PAREN expression RIGHT_PAREN -> ^( UNARY unary_operator expression ) | LEFT_PAREN expression RIGHT_PAREN -> expression );"; }
        }

    }

 

    public static readonly BitSet FOLLOW_code_block_in_prog166 = new BitSet(new ulong[]{0x0000000000000000UL});
    public static readonly BitSet FOLLOW_EOF_in_prog168 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_FUNC_in_function181 = new BitSet(new ulong[]{0x0000002000000000UL});
    public static readonly BitSet FOLLOW_NAME_in_function185 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_LEFT_PAREN_in_function187 = new BitSet(new ulong[]{0x0000002000000040UL});
    public static readonly BitSet FOLLOW_param_list_in_function189 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_RIGHT_PAREN_in_function191 = new BitSet(new ulong[]{0x0000400000000000UL});
    public static readonly BitSet FOLLOW_newlines_in_function193 = new BitSet(new ulong[]{0x000002B1E0F07E20UL});
    public static readonly BitSet FOLLOW_code_block_in_function195 = new BitSet(new ulong[]{0x0000000000000400UL});
    public static readonly BitSet FOLLOW_END_in_function197 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_FUNC_in_function216 = new BitSet(new ulong[]{0x0000002000800000UL});
    public static readonly BitSet FOLLOW_variable_in_function218 = new BitSet(new ulong[]{0x0000000000080000UL});
    public static readonly BitSet FOLLOW_DOT_in_function220 = new BitSet(new ulong[]{0x0000002000000000UL});
    public static readonly BitSet FOLLOW_NAME_in_function224 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_LEFT_PAREN_in_function226 = new BitSet(new ulong[]{0x0000002000000040UL});
    public static readonly BitSet FOLLOW_param_list_in_function228 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_RIGHT_PAREN_in_function230 = new BitSet(new ulong[]{0x0000400000000000UL});
    public static readonly BitSet FOLLOW_newlines_in_function232 = new BitSet(new ulong[]{0x000002B1E0F07E20UL});
    public static readonly BitSet FOLLOW_code_block_in_function234 = new BitSet(new ulong[]{0x0000000000000400UL});
    public static readonly BitSet FOLLOW_END_in_function236 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_FUNC_in_function257 = new BitSet(new ulong[]{0x0000001000000000UL});
    public static readonly BitSet FOLLOW_class_reference_in_function259 = new BitSet(new ulong[]{0x0000000000080000UL});
    public static readonly BitSet FOLLOW_DOT_in_function261 = new BitSet(new ulong[]{0x0000002000000000UL});
    public static readonly BitSet FOLLOW_NAME_in_function265 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_LEFT_PAREN_in_function267 = new BitSet(new ulong[]{0x0000002000000040UL});
    public static readonly BitSet FOLLOW_param_list_in_function269 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_RIGHT_PAREN_in_function271 = new BitSet(new ulong[]{0x0000400000000000UL});
    public static readonly BitSet FOLLOW_newlines_in_function273 = new BitSet(new ulong[]{0x000002B1E0F07E20UL});
    public static readonly BitSet FOLLOW_code_block_in_function275 = new BitSet(new ulong[]{0x0000000000000400UL});
    public static readonly BitSet FOLLOW_END_in_function277 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_FUNC_in_function298 = new BitSet(new ulong[]{0x0000008000800000UL});
    public static readonly BitSet FOLLOW_instance_variable_in_function300 = new BitSet(new ulong[]{0x0000000000080000UL});
    public static readonly BitSet FOLLOW_DOT_in_function302 = new BitSet(new ulong[]{0x0000002000000000UL});
    public static readonly BitSet FOLLOW_NAME_in_function306 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_LEFT_PAREN_in_function308 = new BitSet(new ulong[]{0x0000002000000040UL});
    public static readonly BitSet FOLLOW_param_list_in_function310 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_RIGHT_PAREN_in_function312 = new BitSet(new ulong[]{0x0000400000000000UL});
    public static readonly BitSet FOLLOW_newlines_in_function314 = new BitSet(new ulong[]{0x000002B1E0F07E20UL});
    public static readonly BitSet FOLLOW_code_block_in_function316 = new BitSet(new ulong[]{0x0000000000000400UL});
    public static readonly BitSet FOLLOW_END_in_function318 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_WHILE_in_while_loop343 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_LEFT_PAREN_in_while_loop345 = new BitSet(new ulong[]{0x000002B1E0F00020UL});
    public static readonly BitSet FOLLOW_expression_in_while_loop347 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_RIGHT_PAREN_in_while_loop349 = new BitSet(new ulong[]{0x0000400000000000UL});
    public static readonly BitSet FOLLOW_newlines_in_while_loop351 = new BitSet(new ulong[]{0x000002B1E0F07E20UL});
    public static readonly BitSet FOLLOW_code_block_in_while_loop353 = new BitSet(new ulong[]{0x0000000000000400UL});
    public static readonly BitSet FOLLOW_END_in_while_loop355 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_IF_in_if_statement377 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_LEFT_PAREN_in_if_statement379 = new BitSet(new ulong[]{0x000002B1E0F00020UL});
    public static readonly BitSet FOLLOW_expression_in_if_statement381 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_RIGHT_PAREN_in_if_statement383 = new BitSet(new ulong[]{0x0000400000000000UL});
    public static readonly BitSet FOLLOW_newlines_in_if_statement385 = new BitSet(new ulong[]{0x000002B1E0F0FE20UL});
    public static readonly BitSet FOLLOW_code_block_in_if_statement389 = new BitSet(new ulong[]{0x0000000000008400UL});
    public static readonly BitSet FOLLOW_ELSE_in_if_statement392 = new BitSet(new ulong[]{0x0000400000000000UL});
    public static readonly BitSet FOLLOW_newlines_in_if_statement394 = new BitSet(new ulong[]{0x000002B1E0F07E20UL});
    public static readonly BitSet FOLLOW_code_block_in_if_statement398 = new BitSet(new ulong[]{0x0000000000000400UL});
    public static readonly BitSet FOLLOW_END_in_if_statement402 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CLASS_in_class_def427 = new BitSet(new ulong[]{0x0000001000000000UL});
    public static readonly BitSet FOLLOW_CLASS_NAME_in_class_def431 = new BitSet(new ulong[]{0x0000400000000000UL});
    public static readonly BitSet FOLLOW_newlines_in_class_def433 = new BitSet(new ulong[]{0x000002B1E0F07E20UL});
    public static readonly BitSet FOLLOW_code_block_in_class_def435 = new BitSet(new ulong[]{0x0000000000000400UL});
    public static readonly BitSet FOLLOW_END_in_class_def437 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_param_in_param_list456 = new BitSet(new ulong[]{0x0000000000040002UL});
    public static readonly BitSet FOLLOW_COMMA_in_param_list459 = new BitSet(new ulong[]{0x0000002000000000UL});
    public static readonly BitSet FOLLOW_param_in_param_list461 = new BitSet(new ulong[]{0x0000000000040002UL});
    public static readonly BitSet FOLLOW_NAME_in_param481 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_statement_in_code_block496 = new BitSet(new ulong[]{0x0000400000000000UL});
    public static readonly BitSet FOLLOW_terminator_in_code_block498 = new BitSet(new ulong[]{0x000002B1E0F07A22UL});
    public static readonly BitSet FOLLOW_class_def_in_statement517 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_function_in_statement521 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_while_loop_in_statement525 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_if_statement_in_statement529 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_in_statement533 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_return_stmt_in_statement537 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_assignment_in_statement541 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_mult_expr_in_expression548 = new BitSet(new ulong[]{0x0000000010C00002UL});
    public static readonly BitSet FOLLOW_set_in_expression552 = new BitSet(new ulong[]{0x000002B1E0F00020UL});
    public static readonly BitSet FOLLOW_mult_expr_in_expression565 = new BitSet(new ulong[]{0x0000000010C00002UL});
    public static readonly BitSet FOLLOW_primary_in_mult_expr574 = new BitSet(new ulong[]{0x000000000F000002UL});
    public static readonly BitSet FOLLOW_set_in_mult_expr578 = new BitSet(new ulong[]{0x000002B1E0F00020UL});
    public static readonly BitSet FOLLOW_primary_in_mult_expr595 = new BitSet(new ulong[]{0x000000000F000002UL});
    public static readonly BitSet FOLLOW_PLUS_in_primary608 = new BitSet(new ulong[]{0x0000002000800000UL});
    public static readonly BitSet FOLLOW_variable_in_primary611 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_PLUS_in_primary621 = new BitSet(new ulong[]{0x0000008000800000UL});
    public static readonly BitSet FOLLOW_instance_variable_in_primary624 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_unary_operator_in_primary635 = new BitSet(new ulong[]{0x0000002000800000UL});
    public static readonly BitSet FOLLOW_variable_in_primary638 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_unary_operator_in_primary655 = new BitSet(new ulong[]{0x0000008000800000UL});
    public static readonly BitSet FOLLOW_instance_variable_in_primary658 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_PLUS_in_primary674 = new BitSet(new ulong[]{0x00000201C0800000UL});
    public static readonly BitSet FOLLOW_constant_in_primary677 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_unary_operator_in_primary688 = new BitSet(new ulong[]{0x00000201C0800000UL});
    public static readonly BitSet FOLLOW_constant_in_primary691 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_PLUS_in_primary707 = new BitSet(new ulong[]{0x000000B000800000UL});
    public static readonly BitSet FOLLOW_func_call_in_primary710 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_unary_operator_in_primary720 = new BitSet(new ulong[]{0x000000B000800000UL});
    public static readonly BitSet FOLLOW_func_call_in_primary723 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_unary_operator_in_primary740 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_LEFT_PAREN_in_primary743 = new BitSet(new ulong[]{0x000002B1E0F00020UL});
    public static readonly BitSet FOLLOW_expression_in_primary745 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_RIGHT_PAREN_in_primary747 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_LEFT_PAREN_in_primary763 = new BitSet(new ulong[]{0x000002B1E0F00020UL});
    public static readonly BitSet FOLLOW_expression_in_primary765 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_RIGHT_PAREN_in_primary767 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_unary_operator0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_variable_in_assignment799 = new BitSet(new ulong[]{0x0000000000000010UL});
    public static readonly BitSet FOLLOW_ASSIGN_in_assignment801 = new BitSet(new ulong[]{0x000002B1E0F00020UL});
    public static readonly BitSet FOLLOW_expression_in_assignment803 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_instance_variable_in_assignment820 = new BitSet(new ulong[]{0x0000000000000010UL});
    public static readonly BitSet FOLLOW_ASSIGN_in_assignment822 = new BitSet(new ulong[]{0x000002B1E0F00020UL});
    public static readonly BitSet FOLLOW_expression_in_assignment824 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_NAME_in_variable844 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_INSTANCE_NAME_in_instance_variable858 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CLASS_NAME_in_class_reference872 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_NAME_in_func_call888 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_LEFT_PAREN_in_func_call890 = new BitSet(new ulong[]{0x000002B1E0F00060UL});
    public static readonly BitSet FOLLOW_expr_list_in_func_call894 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_RIGHT_PAREN_in_func_call896 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_variable_in_func_call915 = new BitSet(new ulong[]{0x0000000000080000UL});
    public static readonly BitSet FOLLOW_DOT_in_func_call917 = new BitSet(new ulong[]{0x0000002000000000UL});
    public static readonly BitSet FOLLOW_NAME_in_func_call921 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_LEFT_PAREN_in_func_call923 = new BitSet(new ulong[]{0x000002B1E0F00060UL});
    public static readonly BitSet FOLLOW_expr_list_in_func_call927 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_RIGHT_PAREN_in_func_call929 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_class_reference_in_func_call951 = new BitSet(new ulong[]{0x0000000000080000UL});
    public static readonly BitSet FOLLOW_DOT_in_func_call953 = new BitSet(new ulong[]{0x0000002000000000UL});
    public static readonly BitSet FOLLOW_NAME_in_func_call957 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_LEFT_PAREN_in_func_call959 = new BitSet(new ulong[]{0x000002B1E0F00060UL});
    public static readonly BitSet FOLLOW_expr_list_in_func_call963 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_RIGHT_PAREN_in_func_call965 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_instance_variable_in_func_call987 = new BitSet(new ulong[]{0x0000000000080000UL});
    public static readonly BitSet FOLLOW_DOT_in_func_call989 = new BitSet(new ulong[]{0x0000002000000000UL});
    public static readonly BitSet FOLLOW_NAME_in_func_call993 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_LEFT_PAREN_in_func_call995 = new BitSet(new ulong[]{0x000002B1E0F00060UL});
    public static readonly BitSet FOLLOW_expr_list_in_func_call999 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_RIGHT_PAREN_in_func_call1001 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_in_expr_list1026 = new BitSet(new ulong[]{0x0000000000040002UL});
    public static readonly BitSet FOLLOW_COMMA_in_expr_list1029 = new BitSet(new ulong[]{0x000002B1E0F00020UL});
    public static readonly BitSet FOLLOW_expression_in_expr_list1031 = new BitSet(new ulong[]{0x0000000000040002UL});
    public static readonly BitSet FOLLOW_RET_in_return_stmt1051 = new BitSet(new ulong[]{0x000002B1E0F00020UL});
    public static readonly BitSet FOLLOW_expression_in_return_stmt1053 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_newlines_in_terminator1067 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_EOF_in_terminator1071 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_STRING_LITERAL_in_constant1078 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_INTEGER_in_constant1092 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_FLOAT_in_constant1106 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_BOOL_C_in_constant1120 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_NEWLINE_in_newlines1135 = new BitSet(new ulong[]{0x0000400000000002UL});

}
}